nextclaw 0.16.33 → 0.17.0

package/dist/cli/index.js

@@ -6,32 +6,18 @@ import { APP_NAME as APP_NAME6, APP_TAGLINE } from "@nextclaw/core";
 import { registerRemoteCommands } from "@nextclaw/remote";
 
 // src/cli/runtime.ts
-import {
-  loadConfig as loadConfig21,
-  saveConfig as saveConfig11,
-  getConfigPath as getConfigPath11,
-  getDataDir as getDataDir11,
-  getWorkspacePath as getWorkspacePath13,
-  expandHome as expandHome2,
-  MessageBus as MessageBus3,
-  AgentLoop,
-  ProviderManager as ProviderManager2,
-  resolveConfigSecrets as resolveConfigSecrets7,
-  APP_NAME as APP_NAME5,
-  DEFAULT_WORKSPACE_DIR,
-  DEFAULT_WORKSPACE_PATH
-} from "@nextclaw/core";
+import { loadConfig as loadConfig22, saveConfig as saveConfig11, getConfigPath as getConfigPath11, getDataDir as getDataDir11, getWorkspacePath as getWorkspacePath14, expandHome as expandHome3, MessageBus as MessageBus3, AgentLoop, ProviderManager as ProviderManager2, resolveConfigSecrets as resolveConfigSecrets7, APP_NAME as APP_NAME5, DEFAULT_WORKSPACE_DIR, DEFAULT_WORKSPACE_PATH } from "@nextclaw/core";
 import { RemoteRuntimeActions } from "@nextclaw/remote";
 import {
   getPluginChannelBindings as getPluginChannelBindings6,
   resolvePluginChannelMessageToolHints as resolvePluginChannelMessageToolHints3,
   setPluginRuntimeBridge as setPluginRuntimeBridge3
 } from "@nextclaw/openclaw-compat";
-import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
-import { join as join9, resolve as resolve15 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
+import { join as join9, resolve as resolve16 } from "path";
 import { createInterface as createInterface3 } from "readline";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 
 // src/cli/restart-coordinator.ts
 var RestartCoordinator = class {
@@ -197,6 +183,26 @@ function parseSessionKey(sessionKey) {
   };
 }
 
+// src/cli/runtime-helpers.ts
+import { expandHome, getWorkspacePath } from "@nextclaw/core";
+function resolveSkillsInstallWorkdir(params) {
+  if (params.explicitWorkdir) {
+    return expandHome(params.explicitWorkdir);
+  }
+  return getWorkspacePath(params.configuredWorkspace);
+}
+function parseStartTimeoutMs(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    console.error("Invalid --start-timeout value. Provide milliseconds (e.g. 45000).");
+    process.exit(1);
+  }
+  return Math.floor(parsed);
+}
+
 // src/cli/startup-trace.ts
 var STARTUP_TRACE_ENABLED = process.env.NEXTCLAW_STARTUP_TRACE === "1";
 var STARTUP_TRACE_ORIGIN_MS = Date.now();
@@ -238,7 +244,7 @@ async function measureStartupAsync(step, fn, fields) {
 }
 
 // src/cli/skills/marketplace.ts
-import { cpSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync3, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, 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";
 
@@ -456,8 +462,8 @@ function isRecord(value) {
 var MARKETPLACE_NETWORK_RETRY_ATTEMPTS = 5;
 var MARKETPLACE_NETWORK_RETRY_BASE_MS = 350;
 function sleepMs(ms) {
-  return new Promise((resolve16) => {
-    setTimeout(resolve16, ms);
+  return new Promise((resolve17) => {
+    setTimeout(resolve17, ms);
   });
 }
 function isRetryableMarketplaceNetworkError(error) {
@@ -503,36 +509,54 @@ async function installMarketplaceSkill(options) {
   if (!existsSync4(workdir)) {
     throw new Error(`Workdir does not exist: ${workdir}`);
   }
-  const dirName = options.dir?.trim() || "skills";
-  const destinationDir = isAbsolute(dirName) ? resolve3(dirName, slug) : resolve3(workdir, dirName, slug);
-  const skillFile = join(destinationDir, "SKILL.md");
+  const destinationDir = resolveMarketplaceSkillDestinationDir({
+    workdir,
+    slug,
+    dir: options.dir
+  });
   const apiBase = resolveMarketplaceApiBase(options.apiBaseUrl);
   const item = await fetchMarketplaceSkillItem(apiBase, slug);
   if (item.install.kind === "builtin") {
-    if (!options.force && existsSync4(destinationDir)) {
-      if (existsSync4(skillFile)) {
-        return {
-          slug,
-          destinationDir,
-          alreadyInstalled: true,
-          source: "builtin"
-        };
-      }
-      throw new Error(`Skill directory already exists: ${destinationDir} (use --force)`);
-    }
-    if (existsSync4(destinationDir) && options.force) {
-      rmSync2(destinationDir, { recursive: true, force: true });
-    }
-    installBuiltinSkill(workdir, destinationDir, slug);
-    return {
-      slug,
-      destinationDir,
-      source: "builtin"
-    };
+    return resolveBuiltinMarketplaceInstallResult({
+      workdir,
+      slug
+    });
   }
   const filesPayload = await fetchMarketplaceSkillFiles(apiBase, slug);
-  if (!options.force && existsSync4(destinationDir)) {
-    const existingDirState = inspectMarketplaceSkillDirectory(destinationDir, filesPayload.files);
+  const existingInstall = prepareMarketplaceSkillDestinationDir({
+    destinationDir,
+    files: filesPayload.files,
+    force: options.force,
+    slug
+  });
+  if (existingInstall) {
+    return existingInstall;
+  }
+  await writeMarketplaceSkillFiles({
+    destinationDir,
+    files: filesPayload.files,
+    apiBase,
+    slug
+  });
+  ensureInstalledMarketplaceSkill(destinationDir, slug);
+  return buildMarketplaceInstallResult(slug, destinationDir);
+}
+function resolveMarketplaceSkillDestinationDir(params) {
+  const dirName = params.dir?.trim() || "skills";
+  return isAbsolute(dirName) ? resolve3(dirName, params.slug) : resolve3(params.workdir, dirName, params.slug);
+}
+function resolveBuiltinMarketplaceInstallResult(params) {
+  return {
+    slug: params.slug,
+    destinationDir: resolveBuiltinSkillDir(params.workdir, params.slug),
+    alreadyInstalled: true,
+    source: "builtin"
+  };
+}
+function prepareMarketplaceSkillDestinationDir(params) {
+  const { destinationDir, files, force, slug } = params;
+  if (!force && existsSync4(destinationDir)) {
+    const existingDirState = inspectMarketplaceSkillDirectory(destinationDir, files);
     if (existingDirState === "installed") {
       return {
         slug,
@@ -541,17 +565,20 @@ async function installMarketplaceSkill(options) {
         source: "marketplace"
       };
     }
-    if (existingDirState === "recoverable") {
-      rmSync2(destinationDir, { recursive: true, force: true });
-    } else {
+    if (existingDirState !== "recoverable") {
       throw new Error(`Skill directory already exists: ${destinationDir} (use --force)`);
     }
+    rmSync2(destinationDir, { recursive: true, force: true });
   }
-  if (existsSync4(destinationDir) && options.force) {
+  if (force && existsSync4(destinationDir)) {
     rmSync2(destinationDir, { recursive: true, force: true });
   }
   mkdirSync2(destinationDir, { recursive: true });
-  for (const file of filesPayload.files) {
+  return null;
+}
+async function writeMarketplaceSkillFiles(params) {
+  const { destinationDir, files, apiBase, slug } = params;
+  for (const file of files) {
     const targetPath = resolve3(destinationDir, ...file.path.split("/"));
     const rel = relative(destinationDir, targetPath);
     if (rel.startsWith("..") || isAbsolute(rel)) {
@@ -561,9 +588,13 @@ async function installMarketplaceSkill(options) {
     const bytes = file.contentBase64 ? decodeMarketplaceFileContent(file.path, file.contentBase64) : await fetchMarketplaceSkillFileBlob(apiBase, slug, file);
     writeFileSync2(targetPath, bytes);
   }
+}
+function ensureInstalledMarketplaceSkill(destinationDir, slug) {
   if (!existsSync4(join(destinationDir, "SKILL.md"))) {
     throw new Error(`Marketplace skill ${slug} does not include SKILL.md`);
   }
+}
+function buildMarketplaceInstallResult(slug, destinationDir) {
   return {
     slug,
     destinationDir,
@@ -696,13 +727,13 @@ function collectFiles(rootDir) {
   walk(rootDir, "");
   return output;
 }
-function installBuiltinSkill(workdir, destinationDir, skillName) {
+function resolveBuiltinSkillDir(workdir, skillName) {
   const loader = new SkillsLoader(workdir);
-  const workspaceSkill = loader.listSkills(false).find((skill) => skill.name === skillName && skill.source === "workspace");
-  if (!workspaceSkill) {
-    throw new Error(`Workspace skill not found in local installation: ${skillName}`);
+  const builtinSkill = loader.listSkills(false).find((skill) => skill.name === skillName && skill.source === "builtin");
+  if (!builtinSkill) {
+    throw new Error(`Built-in skill not found in local installation: ${skillName}`);
   }
-  cpSync(dirname(workspaceSkill.path), destinationDir, { recursive: true, force: true });
+  return dirname(builtinSkill.path);
 }
 async function fetchMarketplaceSkillItem(apiBase, slug) {
   return runWithMarketplaceNetworkRetry(async () => {
@@ -909,10 +940,6 @@ async function resolvePublicIp(timeoutMs = 1500) {
   }
   return null;
 }
-function buildServeArgs(options) {
-  const cliPath = fileURLToPath(new URL("./index.js", import.meta.url));
-  return [cliPath, "serve", "--ui-port", String(options.uiPort)];
-}
 function readServiceState() {
   const path2 = resolveServiceStatePath();
   if (!existsSync5(path2)) {
@@ -965,7 +992,7 @@ async function waitForExit(pid, timeoutMs) {
     if (!isProcessRunning(pid)) {
       return true;
     }
-    await new Promise((resolve16) => setTimeout(resolve16, 200));
+    await new Promise((resolve17) => setTimeout(resolve17, 200));
   }
   return !isProcessRunning(pid);
 }
@@ -1096,8 +1123,8 @@ function printAgentResponse(response) {
 async function prompt(rl, question) {
   rl.setPrompt(question);
   rl.prompt();
-  return new Promise((resolve16) => {
-    rl.once("line", (line) => resolve16(line));
+  return new Promise((resolve17) => {
+    rl.once("line", (line) => resolve17(line));
   });
 }
 
@@ -1159,7 +1186,7 @@ import {
   resolveUninstallDirectoryTargets
 } from "@nextclaw/openclaw-compat";
 
-// src/cli/commands/plugin-command-utils.ts
+// src/cli/commands/plugin/plugin-command-utils.ts
 import { builtinProviderIds } from "@nextclaw/runtime";
 var RESERVED_PROVIDER_IDS = builtinProviderIds();
 var RESERVED_TOOL_NAMES = [
@@ -1208,7 +1235,7 @@ function appendPluginCapabilityLines(lines, plugin) {
   }
 }
 
-// src/cli/commands/dev-first-party-plugin-load-paths.ts
+// src/cli/commands/plugin/dev-first-party-plugin-load-paths.ts
 import fs from "fs";
 import path from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -1362,12 +1389,12 @@ var applyDevFirstPartyPluginLoadPaths = (config2, workspaceExtensionsDir) => {
 // src/cli/commands/plugins.ts
 import {
   loadConfig as loadConfig3,
-  getWorkspacePath as getWorkspacePath2
+  getWorkspacePath as getWorkspacePath3
 } from "@nextclaw/core";
 import { createInterface } from "readline";
 import { resolve as resolve7 } from "path";
 
-// src/cli/commands/plugin-mutation-actions.ts
+// src/cli/commands/plugin/plugin-mutation-actions.ts
 import {
   addPluginLoadPath,
   buildPluginStatusReport,
@@ -1380,7 +1407,11 @@ import {
 } from "@nextclaw/openclaw-compat";
 import { existsSync as existsSync6 } from "fs";
 import { resolve as resolve6 } from "path";
-import { expandHome, getWorkspacePath, loadConfig as loadConfig2, saveConfig } from "@nextclaw/core";
+import { expandHome as expandHome2, getWorkspacePath as getWorkspacePath2, loadConfig as loadConfig2, saveConfig } from "@nextclaw/core";
+var pluginInstallLogger = {
+  info: (message) => console.log(message),
+  warn: (message) => console.warn(message)
+};
 function resolveFileNpmSpecToLocalPath(raw) {
   const trimmed = raw.trim();
   if (!trimmed.toLowerCase().startsWith("file:")) {
@@ -1411,6 +1442,79 @@ function isArchivePath(filePath) {
   const lower = filePath.toLowerCase();
   return lower.endsWith(".zip") || lower.endsWith(".tgz") || lower.endsWith(".tar.gz") || lower.endsWith(".tar");
 }
+function saveLinkedPluginInstall(config2, params) {
+  let next = addPluginLoadPath(config2, params.resolvedPath);
+  next = enablePluginInConfig(next, params.pluginId);
+  next = recordPluginInstall(next, {
+    pluginId: params.pluginId,
+    source: "path",
+    sourcePath: params.resolvedPath,
+    installPath: params.resolvedPath,
+    version: params.version ?? void 0
+  });
+  saveConfig(next);
+  return {
+    message: `Linked plugin path: ${params.resolvedPath}`
+  };
+}
+function saveInstalledPluginResult(config2, params) {
+  let next = enablePluginInConfig(config2, params.pluginId);
+  next = recordPluginInstall(next, {
+    pluginId: params.pluginId,
+    source: params.source,
+    sourcePath: params.sourcePath,
+    spec: params.spec,
+    installPath: params.installPath,
+    version: params.version ?? void 0
+  });
+  saveConfig(next);
+  return {
+    message: `Installed plugin: ${params.pluginId}`
+  };
+}
+async function installPluginFromLocalPath(config2, resolvedPath, link) {
+  if (link) {
+    const probe = await installPluginFromPath({ path: resolvedPath, dryRun: true });
+    if (!probe.ok) {
+      throw new Error(probe.error);
+    }
+    return saveLinkedPluginInstall(config2, {
+      resolvedPath,
+      pluginId: probe.pluginId,
+      version: probe.version
+    });
+  }
+  const result = await installPluginFromPath({
+    path: resolvedPath,
+    logger: pluginInstallLogger
+  });
+  if (!result.ok) {
+    throw new Error(result.error);
+  }
+  return saveInstalledPluginResult(config2, {
+    pluginId: result.pluginId,
+    source: isArchivePath(resolvedPath) ? "archive" : "path",
+    sourcePath: resolvedPath,
+    installPath: result.targetDir,
+    version: result.version
+  });
+}
+async function installPluginFromRegistrySpec(config2, spec) {
+  const result = await installPluginFromNpmSpec({
+    spec,
+    logger: pluginInstallLogger
+  });
+  if (!result.ok) {
+    throw new Error(result.error);
+  }
+  return saveInstalledPluginResult(config2, {
+    pluginId: result.pluginId,
+    source: "npm",
+    spec,
+    installPath: result.targetDir,
+    version: result.version
+  });
+}
 async function enablePluginMutation(id) {
   const config2 = loadConfig2();
   const next = enablePluginInConfig(config2, id);
@@ -1429,7 +1533,7 @@ async function disablePluginMutation(id) {
 }
 async function uninstallPluginMutation(id, opts = {}) {
   const config2 = loadConfig2();
-  const workspaceDir = getWorkspacePath(config2.agents.defaults.workspace);
+  const workspaceDir = getWorkspacePath2(config2.agents.defaults.workspace);
   const report = buildPluginStatusReport({
     config: config2,
     workspaceDir,
@@ -1484,50 +1588,10 @@ async function installPluginMutation(pathOrSpec, opts = {}) {
     throw new Error(fileSpec.error);
   }
   const normalized = fileSpec && fileSpec.ok ? fileSpec.path : pathOrSpec;
-  const resolved = resolve6(expandHome(normalized));
+  const resolved = resolve6(expandHome2(normalized));
   const config2 = loadConfig2();
   if (existsSync6(resolved)) {
-    if (opts.link) {
-      const probe = await installPluginFromPath({ path: resolved, dryRun: true });
-      if (!probe.ok) {
-        throw new Error(probe.error);
-      }
-      let next3 = addPluginLoadPath(config2, resolved);
-      next3 = enablePluginInConfig(next3, probe.pluginId);
-      next3 = recordPluginInstall(next3, {
-        pluginId: probe.pluginId,
-        source: "path",
-        sourcePath: resolved,
-        installPath: resolved,
-        version: probe.version
-      });
-      saveConfig(next3);
-      return {
-        message: `Linked plugin path: ${resolved}`
-      };
-    }
-    const result2 = await installPluginFromPath({
-      path: resolved,
-      logger: {
-        info: (message) => console.log(message),
-        warn: (message) => console.warn(message)
-      }
-    });
-    if (!result2.ok) {
-      throw new Error(result2.error);
-    }
-    let next2 = enablePluginInConfig(config2, result2.pluginId);
-    next2 = recordPluginInstall(next2, {
-      pluginId: result2.pluginId,
-      source: isArchivePath(resolved) ? "archive" : "path",
-      sourcePath: resolved,
-      installPath: result2.targetDir,
-      version: result2.version
-    });
-    saveConfig(next2);
-    return {
-      message: `Installed plugin: ${result2.pluginId}`
-    };
+    return installPluginFromLocalPath(config2, resolved, Boolean(opts.link));
   }
   if (opts.link) {
     throw new Error("`--link` requires a local path.");
@@ -1535,31 +1599,10 @@ async function installPluginMutation(pathOrSpec, opts = {}) {
   if (looksLikePath(pathOrSpec)) {
     throw new Error(`Path not found: ${resolved}`);
   }
-  const result = await installPluginFromNpmSpec({
-    spec: pathOrSpec,
-    logger: {
-      info: (message) => console.log(message),
-      warn: (message) => console.warn(message)
-    }
-  });
-  if (!result.ok) {
-    throw new Error(result.error);
-  }
-  let next = enablePluginInConfig(config2, result.pluginId);
-  next = recordPluginInstall(next, {
-    pluginId: result.pluginId,
-    source: "npm",
-    spec: pathOrSpec,
-    installPath: result.targetDir,
-    version: result.version
-  });
-  saveConfig(next);
-  return {
-    message: `Installed plugin: ${result.pluginId}`
-  };
+  return installPluginFromRegistrySpec(config2, pathOrSpec);
 }
 
-// src/cli/commands/plugin-extension-registry.ts
+// src/cli/commands/plugin/plugin-extension-registry.ts
 function toExtensionRegistry(pluginRegistry) {
   return {
     tools: pluginRegistry.tools.map((tool) => ({
@@ -1647,7 +1690,7 @@ var PluginCommands = class {
   }
   pluginsList(opts = {}) {
     const config2 = loadConfig3();
-    const workspaceDir = getWorkspacePath2(config2.agents.defaults.workspace);
+    const workspaceDir = getWorkspacePath3(config2.agents.defaults.workspace);
     const report = buildPluginStatusReport2({
       config: config2,
       workspaceDir,
@@ -1699,7 +1742,7 @@ var PluginCommands = class {
   }
   pluginsInfo(id, opts = {}) {
     const config2 = loadConfig3();
-    const workspaceDir = getWorkspacePath2(config2.agents.defaults.workspace);
+    const workspaceDir = getWorkspacePath3(config2.agents.defaults.workspace);
     const report = buildPluginStatusReport2({
       config: config2,
       workspaceDir,
@@ -1780,7 +1823,7 @@ var PluginCommands = class {
       console.log("`--keep-config` is deprecated, use `--keep-files`.");
     }
     const config2 = loadConfig3();
-    const workspaceDir = getWorkspacePath2(config2.agents.defaults.workspace);
+    const workspaceDir = getWorkspacePath3(config2.agents.defaults.workspace);
     const report = buildPluginStatusReport2({
       config: config2,
       workspaceDir,
@@ -1864,7 +1907,7 @@ var PluginCommands = class {
   }
   pluginsDoctor() {
     const config2 = loadConfig3();
-    const workspaceDir = getWorkspacePath2(config2.agents.defaults.workspace);
+    const workspaceDir = getWorkspacePath3(config2.agents.defaults.workspace);
     const report = buildPluginStatusReport2({
       config: config2,
       workspaceDir,
@@ -1898,8 +1941,8 @@ var PluginCommands = class {
       input: process.stdin,
       output: process.stdout
     });
-    const answer = await new Promise((resolve16) => {
-      rl.question(`${question} [y/N] `, (line) => resolve16(line));
+    const answer = await new Promise((resolve17) => {
+      rl.question(`${question} [y/N] `, (line) => resolve17(line));
     });
     rl.close();
     const normalized = answer.trim().toLowerCase();
@@ -1908,7 +1951,7 @@ var PluginCommands = class {
 };
 
 // src/cli/commands/config.ts
-import { buildReloadPlan, diffConfigPaths, getWorkspacePath as getWorkspacePath3, loadConfig as loadConfig4, saveConfig as saveConfig2 } from "@nextclaw/core";
+import { buildReloadPlan, diffConfigPaths, getWorkspacePath as getWorkspacePath4, loadConfig as loadConfig4, saveConfig as saveConfig2 } from "@nextclaw/core";
 import { getPluginChannelBindings } from "@nextclaw/openclaw-compat";
 
 // src/cli/config-path.ts
@@ -2016,33 +2059,48 @@ function setAtConfigPath(root, pathSegments, value) {
     const next = pathSegments[i + 1];
     const nextIsIndex = Boolean(next && isIndexSegment(next));
     if (Array.isArray(current)) {
-      if (!isIndexSegment(segment)) {
-        throw new Error(`Expected numeric index for array segment "${segment}"`);
-      }
-      const index = Number.parseInt(segment, 10);
-      const existing2 = current[index];
-      if (!existing2 || typeof existing2 !== "object") {
-        current[index] = nextIsIndex ? [] : {};
-      }
-      current = current[index];
+      current = getOrCreateArraySegment(current, segment, nextIsIndex, pathSegments.slice(0, i));
       continue;
     }
-    if (!current || typeof current !== "object") {
-      throw new Error(`Cannot traverse into "${segment}" (not an object)`);
-    }
-    const record = current;
-    const existing = record[segment];
-    if (!existing || typeof existing !== "object") {
-      record[segment] = nextIsIndex ? [] : {};
-    }
-    current = record[segment];
+    current = getOrCreateObjectSegment(current, segment, nextIsIndex);
   }
-  const last = pathSegments[pathSegments.length - 1];
+  setConfigPathValue(current, pathSegments[pathSegments.length - 1], value, pathSegments.slice(0, -1));
+}
+function ensureWritableArrayIndex(current, index, parentPath) {
+  if (!Number.isFinite(index) || index < 0) {
+    throw new Error(`Invalid array index "${index}"`);
+  }
+  if (index <= current.length) {
+    return;
+  }
+  const parentPathExpr = formatConfigPath(parentPath);
+  const parentLabel = parentPathExpr ? `"${parentPathExpr}"` : "the root array";
+  throw new Error(`Cannot set sparse array index ${index} under ${parentLabel}. Set indices in order.`);
+}
+function getOrCreateArraySegment(current, segment, nextIsIndex, parentPath) {
+  const index = parseArrayIndexSegment(segment);
+  ensureWritableArrayIndex(current, index, parentPath);
+  const existing = current[index];
+  if (!existing || typeof existing !== "object") {
+    current[index] = nextIsIndex ? [] : {};
+  }
+  return current[index];
+}
+function getOrCreateObjectSegment(current, segment, nextIsIndex) {
+  if (!current || typeof current !== "object") {
+    throw new Error(`Cannot traverse into "${segment}" (not an object)`);
+  }
+  const record = current;
+  const existing = record[segment];
+  if (!existing || typeof existing !== "object") {
+    record[segment] = nextIsIndex ? [] : {};
+  }
+  return record[segment];
+}
+function setConfigPathValue(current, last, value, parentPath) {
   if (Array.isArray(current)) {
-    if (!isIndexSegment(last)) {
-      throw new Error(`Expected numeric index for array segment "${last}"`);
-    }
-    const index = Number.parseInt(last, 10);
+    const index = parseArrayIndexSegment(last);
+    ensureWritableArrayIndex(current, index, parentPath);
     current[index] = value;
     return;
   }
@@ -2051,6 +2109,23 @@ function setAtConfigPath(root, pathSegments, value) {
   }
   current[last] = value;
 }
+function parseArrayIndexSegment(segment) {
+  if (!isIndexSegment(segment)) {
+    throw new Error(`Expected numeric index for array segment "${segment}"`);
+  }
+  return Number.parseInt(segment, 10);
+}
+function formatConfigPath(pathSegments) {
+  let expr = "";
+  for (const segment of pathSegments) {
+    if (isIndexSegment(segment)) {
+      expr += `[${segment}]`;
+      continue;
+    }
+    expr += expr ? `.${segment}` : segment;
+  }
+  return expr;
+}
 function unsetAtConfigPath(root, pathSegments) {
   let current = root;
   for (let i = 0; i < pathSegments.length - 1; i += 1) {
@@ -2098,7 +2173,7 @@ function unsetAtConfigPath(root, pathSegments) {
   return true;
 }
 
-// src/cli/commands/channel-config-view.ts
+// src/cli/commands/channel/channel-config-view.ts
 import { toPluginConfigView as toPluginConfigView2 } from "@nextclaw/openclaw-compat";
 function resolveChannelConfigView(config2, bindings) {
   return toPluginConfigView2(config2, bindings);
@@ -2221,7 +2296,7 @@ var ConfigCommands = class {
     };
   }
   loadPluginChannelBindings(config2) {
-    const workspaceDir = getWorkspacePath3(config2.agents.defaults.workspace);
+    const workspaceDir = getWorkspacePath4(config2.agents.defaults.workspace);
     const pluginRegistry = loadPluginRegistry(config2, workspaceDir);
     return {
       bindings: getPluginChannelBindings(pluginRegistry)
@@ -2797,7 +2872,7 @@ var SecretsCommands = class {
 
 // src/cli/commands/channels.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { getWorkspacePath as getWorkspacePath4, loadConfig as loadConfig7, saveConfig as saveConfig5 } from "@nextclaw/core";
+import { getWorkspacePath as getWorkspacePath5, loadConfig as loadConfig7, saveConfig as saveConfig5 } from "@nextclaw/core";
 import { BUILTIN_CHANNEL_PLUGIN_IDS, builtinProviderIds as builtinProviderIds2 } from "@nextclaw/runtime";
 import { buildPluginStatusReport as buildPluginStatusReport3, enablePluginInConfig as enablePluginInConfig2, getPluginChannelBindings as getPluginChannelBindings2 } from "@nextclaw/openclaw-compat";
 var CHANNEL_LABELS = {
@@ -2820,7 +2895,7 @@ var ChannelCommands = class {
   }
   channelsStatus() {
     const config2 = loadConfig7();
-    const workspaceDir = getWorkspacePath4(config2.agents.defaults.workspace);
+    const workspaceDir = getWorkspacePath5(config2.agents.defaults.workspace);
     const pluginRegistry = loadPluginRegistry(config2, workspaceDir);
     const channelConfig = resolveChannelConfigView(config2, getPluginChannelBindings2(pluginRegistry));
     console.log("Channel Status");
@@ -2878,7 +2953,7 @@ var ChannelCommands = class {
     }
   }
   resolvePluginChannelContext(config2, channelId) {
-    const workspaceDir = getWorkspacePath4(config2.agents.defaults.workspace);
+    const workspaceDir = getWorkspacePath5(config2.agents.defaults.workspace);
     const pluginRegistry = loadPluginRegistry(config2, workspaceDir);
     const bindings = getPluginChannelBindings2(pluginRegistry);
     const binding = bindings.find((entry) => entry.channelId === channelId || entry.pluginId === channelId);
@@ -2954,7 +3029,7 @@ var ChannelCommands = class {
       process.exit(1);
     }
     const config2 = loadConfig7();
-    const workspaceDir = getWorkspacePath4(config2.agents.defaults.workspace);
+    const workspaceDir = getWorkspacePath5(config2.agents.defaults.workspace);
     const pluginRegistry = loadPluginRegistry(config2, workspaceDir);
     const bindings = getPluginChannelBindings2(pluginRegistry);
     const binding = bindings.find((entry) => entry.channelId === channelId || entry.pluginId === channelId);
@@ -3005,7 +3080,7 @@ var ChannelCommands = class {
   }
 };
 
-// src/cli/commands/cron/cron-local.service.ts
+// src/cli/commands/cron-support/cron-local.service.ts
 import { CronService, getDataDir as getDataDir3 } from "@nextclaw/core";
 import { join as join3 } from "path";
 function createCronService() {
@@ -3039,6 +3114,7 @@ var CronLocalService = class {
       name: opts.name,
       schedule,
       message: opts.message,
+      agentId: opts.agent,
       deliver: Boolean(opts.deliver),
       channel: opts.channel,
       to: opts.to,
@@ -3060,7 +3136,7 @@ var CronLocalService = class {
   };
 };
 
-// src/cli/commands/cron/cron-job.utils.ts
+// src/cli/commands/cron-support/cron-job.utils.ts
 function formatCronSchedule(schedule) {
   if (schedule.kind === "every") {
     return `every ${Math.round((schedule.everyMs ?? 0) / 1e3)}s`;
@@ -3239,11 +3315,128 @@ var CronCommands = class {
   };
 };
 
+// src/cli/commands/agents.ts
+import {
+  BUILTIN_MAIN_AGENT_ID,
+  createAgentProfile,
+  loadConfig as loadConfig8,
+  removeAgentProfile,
+  resolveEffectiveAgentProfiles,
+  updateAgentProfile
+} from "@nextclaw/core";
+var AgentCommands = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  agentsList = (opts = {}) => {
+    const config2 = loadConfig8();
+    const agents = resolveEffectiveAgentProfiles(config2).map((agent) => this.toAgentListEntry(agent));
+    if (opts.json) {
+      console.log(JSON.stringify(agents, null, 2));
+      return;
+    }
+    for (const agent of agents) {
+      const head = agent.builtIn ? `${agent.id} (built-in)` : agent.id;
+      console.log(head);
+      console.log(`  name: ${agent.displayName ?? "-"}`);
+      console.log(`  description: ${agent.description ?? "-"}`);
+      console.log(`  home: ${agent.workspace}`);
+      console.log(`  avatar: ${agent.avatar ?? "-"}`);
+    }
+  };
+  agentsNew = async (agentId, opts = {}) => {
+    const created = createAgentProfile(
+      {
+        id: agentId,
+        displayName: opts.name,
+        description: opts.description,
+        avatar: opts.avatar,
+        home: opts.home
+      },
+      {
+        initializeHomeDirectory: this.deps.initializeAgentHomeDirectory
+      }
+    );
+    if (opts.json) {
+      console.log(JSON.stringify({
+        agent: created,
+        restartRequired: true
+      }, null, 2));
+      return;
+    }
+    await this.deps.requestRestart({
+      reason: "agents-updated",
+      manualMessage: `Created agent '${created.id}'. Restart ${this.deps.appName} to apply agent runtime changes.`
+    });
+    console.log(`\u2713 Created agent ${created.id}`);
+    console.log(`  name: ${created.displayName ?? "-"}`);
+    console.log(`  description: ${created.description ?? "-"}`);
+    console.log(`  home: ${created.workspace}`);
+    console.log(`  avatar: ${created.avatar ?? "-"}`);
+  };
+  agentsUpdate = async (agentId, opts = {}) => {
+    const updated = updateAgentProfile({
+      id: agentId,
+      displayName: opts.name,
+      description: opts.description,
+      avatar: opts.avatar
+    });
+    if (opts.json) {
+      console.log(JSON.stringify({
+        agent: updated,
+        restartRequired: true
+      }, null, 2));
+      return;
+    }
+    await this.deps.requestRestart({
+      reason: "agents-updated",
+      manualMessage: `Updated agent '${updated.id}'. Restart ${this.deps.appName} to apply agent runtime changes.`
+    });
+    console.log(`\u2713 Updated agent ${updated.id}`);
+    console.log(`  name: ${updated.displayName ?? "-"}`);
+    console.log(`  description: ${updated.description ?? "-"}`);
+    console.log(`  home: ${updated.workspace}`);
+    console.log(`  avatar: ${updated.avatar ?? "-"}`);
+  };
+  agentsRemove = async (agentId, opts = {}) => {
+    if (agentId.trim().toLowerCase() === BUILTIN_MAIN_AGENT_ID) {
+      throw new Error(`agent id '${BUILTIN_MAIN_AGENT_ID}' is reserved`);
+    }
+    const removed = removeAgentProfile(agentId);
+    if (!removed) {
+      throw new Error(`agent '${agentId}' not found`);
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({
+        removed: true,
+        agentId,
+        restartRequired: true
+      }, null, 2));
+      return;
+    }
+    await this.deps.requestRestart({
+      reason: "agents-updated",
+      manualMessage: `Removed agent '${agentId}'. Restart ${this.deps.appName} to apply agent runtime changes.`
+    });
+    console.log(`\u2713 Removed agent ${agentId}`);
+  };
+  toAgentListEntry = (agent) => {
+    return {
+      id: agent.id,
+      displayName: agent.displayName ?? null,
+      description: agent.description ?? null,
+      avatar: agent.avatar ?? null,
+      workspace: agent.workspace,
+      builtIn: agent.builtIn === true
+    };
+  };
+};
+
 // src/cli/commands/platform-auth.ts
-import { getConfigPath as getConfigPath3, loadConfig as loadConfig8, saveConfig as saveConfig6 } from "@nextclaw/core";
+import { getConfigPath as getConfigPath3, loadConfig as loadConfig9, saveConfig as saveConfig6 } from "@nextclaw/core";
 import { createInterface as createInterface2 } from "readline";
 
-// src/cli/commands/platform-api-base.ts
+// src/cli/commands/remote-support/platform-api-base.ts
 var DEFAULT_PLATFORM_API_BASE = "https://ai-gateway-api.nextclaw.io/v1";
 var INVALID_PLATFORM_HINT = `Use ${DEFAULT_PLATFORM_API_BASE} or the platform root URL without a trailing path.`;
 function trimTrailingSlash(value) {
@@ -3294,7 +3487,7 @@ function buildPlatformApiBaseErrorMessage(inputApiBase, rawMessage) {
 // src/cli/commands/platform-auth.ts
 function resolveProviderConfig(opts) {
   const configPath = getConfigPath3();
-  const config2 = loadConfig8(configPath);
+  const config2 = loadConfig9(configPath);
   const providers = config2.providers;
   const nextclawProvider = providers.nextclaw ?? {
     displayName: "",
@@ -3542,14 +3735,14 @@ var PlatformAuthCommands = class {
 };
 
 // src/cli/commands/remote.ts
-import { getConfigPath as getConfigPath5, loadConfig as loadConfig10, saveConfig as saveConfig7 } from "@nextclaw/core";
+import { getConfigPath as getConfigPath5, loadConfig as loadConfig11, saveConfig as saveConfig7 } from "@nextclaw/core";
 import {
   readPlatformSessionTokenState
 } from "@nextclaw/remote";
 import { hostname } from "os";
 
-// src/cli/commands/remote-runtime-support.ts
-import { getConfigPath as getConfigPath4, getDataDir as getDataDir4, loadConfig as loadConfig9 } from "@nextclaw/core";
+// src/cli/commands/remote-support/remote-runtime-support.ts
+import { getConfigPath as getConfigPath4, getDataDir as getDataDir4, loadConfig as loadConfig10 } from "@nextclaw/core";
 import {
   RemoteConnector,
   RemotePlatformClient,
@@ -3564,7 +3757,7 @@ function hasRunningNextclawManagedService() {
 }
 function createNextclawRemotePlatformClient() {
   return new RemotePlatformClient({
-    loadConfig: () => loadConfig9(getConfigPath4()),
+    loadConfig: () => loadConfig10(getConfigPath4()),
     getDataDir: getDataDir4,
     getPackageVersion,
     resolvePlatformBase: (rawApiBase) => resolvePlatformApiBase({
@@ -3695,7 +3888,7 @@ var RemoteCommands = class {
     this.deps = deps;
   }
   updateConfig(params = {}) {
-    const config2 = loadConfig10(getConfigPath5());
+    const config2 = loadConfig11(getConfigPath5());
     const nextEnabled = typeof params.enabled === "boolean" ? params.enabled : config2.remote.enabled;
     const nextPlatformApiBase = typeof params.apiBase === "string" ? params.apiBase.trim() : config2.remote.platformApiBase;
     const nextDeviceName = typeof params.name === "string" ? params.name.trim() : config2.remote.deviceName;
@@ -3732,7 +3925,7 @@ var RemoteCommands = class {
     });
   }
   getStatusView() {
-    const config2 = loadConfig10(getConfigPath5());
+    const config2 = loadConfig11(getConfigPath5());
     const snapshot = resolveNextclawRemoteStatusSnapshot(config2);
     const resolvedLocalOrigin = snapshot.runtime?.localOrigin ?? this.deps.currentLocalOrigin ?? resolveConfiguredLocalOrigin(config2);
     return {
@@ -3768,7 +3961,7 @@ var RemoteCommands = class {
     }
   }
   async getDoctorView() {
-    const config2 = loadConfig10(getConfigPath5());
+    const config2 = loadConfig11(getConfigPath5());
     const snapshot = resolveNextclawRemoteStatusSnapshot(config2);
     const localOrigin = snapshot.runtime?.localOrigin ?? this.deps.currentLocalOrigin ?? resolveConfiguredLocalOrigin(config2);
     const localUi = await probeLocalUi(localOrigin);
@@ -3824,13 +4017,13 @@ import {
   APP_NAME as APP_NAME2,
   getConfigPath as getConfigPath6,
   getDataDir as getDataDir5,
-  getWorkspacePath as getWorkspacePath5,
+  getWorkspacePath as getWorkspacePath6,
   hasSecretRef,
-  loadConfig as loadConfig11
+  loadConfig as loadConfig12
 } from "@nextclaw/core";
 import { listBuiltinProviders } from "@nextclaw/runtime";
 
-// src/cli/commands/diagnostics-render.ts
+// src/cli/commands/diagnostics-support/diagnostics-render.ts
 import { APP_NAME } from "@nextclaw/core";
 function printStatusReport(params) {
   const { logo, report, verbose } = params;
@@ -4012,8 +4205,8 @@ var DiagnosticsCommands = class {
   }
   async collectRuntimeStatus(params) {
     const configPath = getConfigPath6();
-    const config2 = loadConfig11();
-    const workspacePath = getWorkspacePath5(config2.agents.defaults.workspace);
+    const config2 = loadConfig12();
+    const workspacePath = getWorkspacePath6(config2.agents.defaults.workspace);
     const serviceStatePath = resolve8(getDataDir5(), "run", "service.json");
     const fixActions = [];
     let serviceState = readServiceState();
@@ -4183,17 +4376,17 @@ var DiagnosticsCommands = class {
     }
   }
   async checkPortAvailability(params) {
-    return await new Promise((resolve16) => {
+    return await new Promise((resolve17) => {
       const server = createNetServer();
       server.once("error", (error) => {
-        resolve16({
+        resolve17({
           available: false,
           detail: `bind failed on ${params.host}:${params.port} (${String(error)})`
         });
       });
       server.listen(params.port, params.host, () => {
         server.close(() => {
-          resolve16({
+          resolve17({
             available: true,
             detail: `bind ok on ${params.host}:${params.port}`
           });
@@ -4210,9 +4403,9 @@ import {
   setPluginRuntimeBridge as setPluginRuntimeBridge2,
   stopPluginChannelGateways as stopPluginChannelGateways2
 } from "@nextclaw/openclaw-compat";
-import { appendFileSync, closeSync as closeSync2, cpSync as cpSync2, existsSync as existsSync11, mkdirSync as mkdirSync5, openSync as openSync2 } from "fs";
-import { dirname as dirname3, join as join7, resolve as resolve13 } from "path";
-import { spawn as spawn3 } from "child_process";
+import { appendFileSync } from "fs";
+import { join as join7, resolve as resolve14 } from "path";
+import { spawn as spawn4 } from "child_process";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
 import { createServer as createNetServer2 } from "net";
@@ -4237,12 +4430,12 @@ var MissingProvider = class extends LLMProvider {
   }
 };
 
-// src/cli/commands/service-marketplace-installer.ts
-import { getWorkspacePath as getWorkspacePath6, loadConfig as loadConfig13 } from "@nextclaw/core";
+// src/cli/commands/service-support/marketplace/service-marketplace-installer.ts
+import { getWorkspacePath as getWorkspacePath7, loadConfig as loadConfig14 } from "@nextclaw/core";
 import { existsSync as existsSync8, rmSync as rmSync4 } from "fs";
 import { join as join4 } from "path";
 
-// src/cli/commands/service-marketplace-helpers.ts
+// src/cli/commands/service-support/marketplace/service-marketplace-helpers.ts
 var containsAbsoluteFsPath = (line) => {
   const normalized = line.trim();
   if (!normalized) {
@@ -4287,8 +4480,8 @@ var buildMarketplaceSkillInstallArgs = (params) => {
   return args;
 };
 
-// src/cli/commands/service-mcp-marketplace-ops.ts
-import { loadConfig as loadConfig12, saveConfig as saveConfig8 } from "@nextclaw/core";
+// src/cli/commands/service-support/marketplace/service-mcp-marketplace-ops.ts
+import { loadConfig as loadConfig13, saveConfig as saveConfig8 } from "@nextclaw/core";
 import { McpDoctorFacade as McpDoctorFacade2, McpMutationService as McpMutationService2 } from "@nextclaw/mcp";
 var ServiceMcpMarketplaceOps = class {
   constructor(options) {
@@ -4356,18 +4549,18 @@ var ServiceMcpMarketplaceOps = class {
   }
   createMutationService() {
     return new McpMutationService2({
-      getConfig: () => loadConfig12(),
+      getConfig: () => loadConfig13(),
       saveConfig: (config2) => saveConfig8(config2)
     });
   }
   createDoctorFacade() {
     return new McpDoctorFacade2({
-      getConfig: () => loadConfig12()
+      getConfig: () => loadConfig13()
     });
   }
 };
 
-// src/cli/commands/service-marketplace-installer.ts
+// src/cli/commands/service-support/marketplace/service-marketplace-installer.ts
 var ServiceMarketplaceInstaller = class {
   constructor(deps) {
     this.deps = deps;
@@ -4403,7 +4596,7 @@ var ServiceMarketplaceInstaller = class {
     if (params.kind && params.kind !== "marketplace") {
       throw new Error(`Unsupported marketplace skill kind: ${params.kind}`);
     }
-    const workspace = getWorkspacePath6(loadConfig13().agents.defaults.workspace);
+    const workspace = getWorkspacePath7(loadConfig14().agents.defaults.workspace);
     const args = buildMarketplaceSkillInstallArgs({
       slug: params.slug,
       workspace,
@@ -4442,7 +4635,7 @@ var ServiceMarketplaceInstaller = class {
     return { message: result.message };
   }
   async uninstallSkill(slug) {
-    const workspace = getWorkspacePath6(loadConfig13().agents.defaults.workspace);
+    const workspace = getWorkspacePath7(loadConfig14().agents.defaults.workspace);
     const targetDir = join4(workspace, "skills", slug);
     if (!existsSync8(targetDir)) {
       throw new Error(`Skill not installed in workspace: ${slug}`);
@@ -4471,70 +4664,12 @@ var ServiceMarketplaceInstaller = class {
   }
 };
 
-// src/cli/commands/service-startup-support.ts
-import chokidar from "chokidar";
-import { resolve as resolve9 } from "path";
-var pluginGatewayLogger = {
-  info: (message) => console.log(`[plugins] ${message}`),
-  warn: (message) => console.warn(`[plugins] ${message}`),
-  error: (message) => console.error(`[plugins] ${message}`),
-  debug: (message) => console.debug(`[plugins] ${message}`)
-};
-function logPluginGatewayDiagnostics(diagnostics) {
-  for (const diag of diagnostics) {
-    const prefix = diag.pluginId ? `${diag.pluginId}: ` : "";
-    const text = `${prefix}${diag.message}`;
-    if (diag.level === "error") {
-      console.error(`[plugins] ${text}`);
-    } else {
-      console.warn(`[plugins] ${text}`);
-    }
-  }
-}
-async function startGatewaySupportServices(params) {
-  if (params.cronJobs > 0) {
-    console.log(`\u2713 Cron: ${params.cronJobs} scheduled jobs`);
-  }
-  console.log("\u2713 Heartbeat: every 30m");
-  params.remoteModule?.start();
-  params.watchConfigFile();
-  await params.startCron();
-  await params.startHeartbeat();
-}
-function watchCronStoreFile(params) {
-  const cronStorePath = resolve9(params.cronStorePath);
-  const watcher = chokidar.watch(cronStorePath, {
-    ignoreInitial: true,
-    awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
-  });
-  watcher.on("all", (event, changedPath) => {
-    if (resolve9(changedPath) !== cronStorePath) {
-      return;
-    }
-    if (event === "add" || event === "change" || event === "unlink") {
-      try {
-        params.reloadCronStore();
-      } catch (error) {
-        console.error(`Cron store reload failed (${event}): ${String(error)}`);
-      }
-    }
-  });
-}
-
-// src/cli/commands/cli-subcommand-launch.ts
-import { createRequire } from "module";
-import { extname, resolve as resolve10 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-var require2 = createRequire(import.meta.url);
-var resolveCliSubcommandEntry = (params) => {
-  const argvEntry = params.argvEntry?.trim();
-  if (argvEntry) {
-    return resolve10(argvEntry);
-  }
-  return fileURLToPath3(new URL("../index.js", params.importMetaUrl));
-};
+// src/cli/commands/service-support/runtime/service-managed-startup.ts
+import { closeSync as closeSync2, mkdirSync as mkdirSync5, openSync as openSync2 } from "fs";
+import { resolve as resolve10 } from "path";
+import { spawn as spawn2 } from "child_process";
 
-// src/cli/commands/service-remote-runtime.ts
+// src/cli/commands/service-support/runtime/service-remote-runtime.ts
 import { RemoteServiceModule } from "@nextclaw/remote";
 import {
   closeSync,
@@ -4546,10 +4681,10 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync4
 } from "fs";
-import { dirname as dirname2, resolve as resolve11 } from "path";
+import { dirname as dirname2, resolve as resolve9 } from "path";
 import { getDataDir as getDataDir6 } from "@nextclaw/core";
 function resolveRemoteOwnershipLockPath() {
-  return resolve11(getDataDir6(), "run", "remote-owner.lock.json");
+  return resolve9(getDataDir6(), "run", "remote-owner.lock.json");
 }
 function readRemoteOwnershipRecord(lockPath) {
   try {
@@ -4736,20 +4871,230 @@ function writeReadyManagedServiceState(params) {
   return state;
 }
 
-// src/cli/commands/remote-access-host.ts
-import { getConfigPath as getConfigPath8, loadConfig as loadConfig15 } from "@nextclaw/core";
-import { readPlatformSessionTokenState as readPlatformSessionTokenState2 } from "@nextclaw/remote";
-
-// src/cli/commands/remote-access-service-control.ts
-import { getConfigPath as getConfigPath7, loadConfig as loadConfig14 } from "@nextclaw/core";
-import { spawn as spawn2 } from "child_process";
-var FORCED_PUBLIC_UI_HOST = "0.0.0.0";
-function resolveRemoteServiceView(currentUi) {
-  if (currentUi) {
-    return {
-      running: true,
-      currentProcess: true,
-      pid: process.pid,
+// src/cli/commands/service-support/runtime/service-managed-startup.ts
+function toObjectRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function hasSessionRoutingMetadata(params) {
+  const context = toObjectRecord(params.metadata.last_delivery_context) ?? {};
+  const hasPrimaryRoute = Boolean(params.normalizeOptionalString(context.channel)) && Boolean(params.normalizeOptionalString(context.chatId));
+  const hasFallbackRoute = Boolean(params.normalizeOptionalString(params.metadata.last_channel)) && Boolean(params.normalizeOptionalString(params.metadata.last_to));
+  return hasPrimaryRoute || hasFallbackRoute;
+}
+function resolveManagedServiceUiBinding(state) {
+  try {
+    const parsed = new URL(state.uiUrl);
+    const parsedPort = Number(parsed.port || 80);
+    return {
+      host: state.uiHost ?? parsed.hostname,
+      port: Number.isFinite(parsedPort) ? parsedPort : state.uiPort ?? 55667
+    };
+  } catch {
+    return {
+      host: state.uiHost ?? "127.0.0.1",
+      port: state.uiPort ?? 55667
+    };
+  }
+}
+function resolveSessionRouteCandidate(params) {
+  const sessionRecord = toObjectRecord(params.session);
+  const key = params.normalizeOptionalString(sessionRecord?.key);
+  if (!key || key.startsWith("cli:")) {
+    return null;
+  }
+  const metadata = toObjectRecord(sessionRecord?.metadata) ?? {};
+  if (!hasSessionRoutingMetadata({ metadata, normalizeOptionalString: params.normalizeOptionalString })) {
+    return null;
+  }
+  const updatedAtRaw = params.normalizeOptionalString(sessionRecord?.updated_at);
+  const updatedAt = updatedAtRaw ? Date.parse(updatedAtRaw) : Number.NaN;
+  return {
+    key,
+    updatedAt: Number.isFinite(updatedAt) ? updatedAt : 0
+  };
+}
+function spawnManagedService(params) {
+  const logPath = params.resolveServiceLogPath();
+  const logDir = resolve10(logPath, "..");
+  mkdirSync5(logDir, { recursive: true });
+  const logFd = openSync2(logPath, "a");
+  const readinessTimeoutMs = params.resolveStartupTimeoutMs(params.startupTimeoutMs);
+  const quickPhaseTimeoutMs = Math.min(8e3, readinessTimeoutMs);
+  const extendedPhaseTimeoutMs = Math.max(0, readinessTimeoutMs - quickPhaseTimeoutMs);
+  params.appendStartupStage(
+    logPath,
+    `start requested: ui=${params.uiConfig.host}:${params.uiConfig.port}, readinessTimeoutMs=${readinessTimeoutMs}`
+  );
+  console.log(`Starting ${params.appName} background service (readiness timeout ${Math.ceil(readinessTimeoutMs / 1e3)}s)...`);
+  const serveArgs = ["serve", "--ui-port", String(params.uiConfig.port)];
+  params.appendStartupStage(logPath, `spawning background process: ${process.execPath} ${[...process.execArgv, ...serveArgs].join(" ")}`);
+  const child = spawn2(process.execPath, [...process.execArgv, ...serveArgs], {
+    env: process.env,
+    stdio: ["ignore", logFd, logFd],
+    detached: true
+  });
+  params.appendStartupStage(logPath, `spawned background process pid=${child.pid ?? "unknown"}`);
+  closeSync2(logFd);
+  if (!child.pid) {
+    params.appendStartupStage(logPath, "spawn failed: child pid missing");
+    console.error("Error: Failed to start background service.");
+    params.printStartupFailureDiagnostics({
+      uiUrl: params.uiUrl,
+      apiUrl: params.apiUrl,
+      healthUrl: params.healthUrl,
+      logPath,
+      lastProbeError: null
+    });
+    return null;
+  }
+  const snapshot = {
+    pid: child.pid,
+    uiUrl: params.uiUrl,
+    apiUrl: params.apiUrl,
+    uiHost: params.uiConfig.host,
+    uiPort: params.uiConfig.port,
+    logPath
+  };
+  writeInitialManagedServiceState({
+    config: params.config,
+    readinessTimeoutMs,
+    snapshot
+  });
+  return {
+    child,
+    logPath,
+    readinessTimeoutMs,
+    quickPhaseTimeoutMs,
+    extendedPhaseTimeoutMs,
+    snapshot
+  };
+}
+async function waitForManagedServiceReadiness(params) {
+  params.appendStartupStage(params.logPath, `health probe started: ${params.healthUrl} (phase=quick, timeoutMs=${params.quickPhaseTimeoutMs})`);
+  let readiness = await params.waitForBackgroundServiceReady({
+    pid: params.childPid,
+    healthUrl: params.healthUrl,
+    timeoutMs: params.quickPhaseTimeoutMs
+  });
+  if (!readiness.ready && params.isProcessRunning(params.childPid) && params.extendedPhaseTimeoutMs > 0) {
+    console.warn(
+      `Warning: Background service is still running but not ready after ${Math.ceil(params.quickPhaseTimeoutMs / 1e3)}s; waiting up to ${Math.ceil(params.extendedPhaseTimeoutMs / 1e3)}s more.`
+    );
+    params.appendStartupStage(
+      params.logPath,
+      `health probe entering extended phase (timeoutMs=${params.extendedPhaseTimeoutMs}, lastError=${readiness.lastProbeError ?? "none"})`
+    );
+    readiness = await params.waitForBackgroundServiceReady({
+      pid: params.childPid,
+      healthUrl: params.healthUrl,
+      timeoutMs: params.extendedPhaseTimeoutMs
+    });
+  }
+  if (!readiness.ready && params.isProcessRunning(params.childPid)) {
+    params.appendStartupStage(
+      params.logPath,
+      `startup degraded: process alive but health probe timed out after ${params.readinessTimeoutMs}ms (lastError=${readiness.lastProbeError ?? "none"})`
+    );
+  }
+  return readiness;
+}
+async function reportManagedServiceStart(params) {
+  if (!params.readiness.ready) {
+    const hint = params.readiness.lastProbeError ? ` Last probe error: ${params.readiness.lastProbeError}` : "";
+    console.warn(
+      `Warning: ${params.appName} is running (PID ${params.state.pid}) but not healthy yet after ${Math.ceil(params.readinessTimeoutMs / 1e3)}s. Marked as degraded.${hint}`
+    );
+    console.warn(`Tip: Run "${params.appName} status --json" and check logs: ${params.state.logPath}`);
+  } else {
+    console.log(`\u2713 ${params.appName} started in background (PID ${params.state.pid})`);
+  }
+  console.log(`UI: ${params.uiUrl}`);
+  console.log(`API: ${params.apiUrl}`);
+  await params.printPublicUiUrls(params.uiConfig.host, params.uiConfig.port);
+  console.log(`Logs: ${params.state.logPath}`);
+  params.printServiceControlHints();
+}
+
+// src/cli/commands/service-support/gateway/service-startup-support.ts
+import chokidar from "chokidar";
+import { resolve as resolve11 } from "path";
+var pluginGatewayLogger = {
+  info: (message) => console.log(`[plugins] ${message}`),
+  warn: (message) => console.warn(`[plugins] ${message}`),
+  error: (message) => console.error(`[plugins] ${message}`),
+  debug: (message) => console.debug(`[plugins] ${message}`)
+};
+function logPluginGatewayDiagnostics(diagnostics) {
+  for (const diag of diagnostics) {
+    const prefix = diag.pluginId ? `${diag.pluginId}: ` : "";
+    const text = `${prefix}${diag.message}`;
+    if (diag.level === "error") {
+      console.error(`[plugins] ${text}`);
+    } else {
+      console.warn(`[plugins] ${text}`);
+    }
+  }
+}
+async function startGatewaySupportServices(params) {
+  if (params.cronJobs > 0) {
+    console.log(`\u2713 Cron: ${params.cronJobs} scheduled jobs`);
+  }
+  console.log("\u2713 Heartbeat: every 30m");
+  params.remoteModule?.start();
+  params.watchConfigFile();
+  await params.startCron();
+  await params.startHeartbeat();
+}
+function watchCronStoreFile(params) {
+  const cronStorePath = resolve11(params.cronStorePath);
+  const watcher = chokidar.watch(cronStorePath, {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
+  });
+  watcher.on("all", (event, changedPath) => {
+    if (resolve11(changedPath) !== cronStorePath) {
+      return;
+    }
+    if (event === "add" || event === "change" || event === "unlink") {
+      try {
+        params.reloadCronStore();
+      } catch (error) {
+        console.error(`Cron store reload failed (${event}): ${String(error)}`);
+      }
+    }
+  });
+}
+
+// src/cli/commands/service-support/marketplace/cli-subcommand-launch.ts
+import { createRequire } from "module";
+import { extname, resolve as resolve12 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var require2 = createRequire(import.meta.url);
+var resolveCliSubcommandEntry = (params) => {
+  const argvEntry = params.argvEntry?.trim();
+  if (argvEntry) {
+    return resolve12(argvEntry);
+  }
+  return fileURLToPath3(new URL("../index.js", params.importMetaUrl));
+};
+
+// src/cli/commands/remote-support/remote-access-host.ts
+import { getConfigPath as getConfigPath8, loadConfig as loadConfig16 } from "@nextclaw/core";
+import { readPlatformSessionTokenState as readPlatformSessionTokenState2 } from "@nextclaw/remote";
+
+// src/cli/commands/remote-support/remote-access-service-control.ts
+import { getConfigPath as getConfigPath7, loadConfig as loadConfig15 } from "@nextclaw/core";
+import { spawn as spawn3 } from "child_process";
+var FORCED_PUBLIC_UI_HOST = "0.0.0.0";
+function resolveRemoteServiceView(currentUi) {
+  if (currentUi) {
+    return {
+      running: true,
+      currentProcess: true,
+      pid: process.pid,
       uiUrl: resolveUiApiBase(currentUi.host, currentUi.port),
       uiPort: currentUi.port
     };
@@ -4830,7 +5175,7 @@ async function controlManagedService(action, deps) {
   return { accepted: true, action, message: "Managed service restarted." };
 }
 function resolveManagedUiOverrides() {
-  const config2 = loadConfig14(getConfigPath7());
+  const config2 = loadConfig15(getConfigPath7());
   const resolved = resolveUiConfig(config2, {
     enabled: true,
     host: FORCED_PUBLIC_UI_HOST,
@@ -4891,7 +5236,7 @@ function launchManagedSelfControl(params = {}) {
     "  process.exit(0);",
     "}, 250);"
   ].join("");
-  const helper = spawn2(process.execPath, ["-e", script], {
+  const helper = spawn3(process.execPath, ["-e", script], {
     detached: true,
     stdio: "ignore",
     env: process.env,
@@ -4900,7 +5245,7 @@ function launchManagedSelfControl(params = {}) {
   helper.unref();
 }
 
-// src/cli/commands/remote-access-host.ts
+// src/cli/commands/remote-support/remote-access-host.ts
 function normalizeOptionalString4(value) {
   if (typeof value !== "string") {
     return null;
@@ -4930,7 +5275,7 @@ var RemoteAccessHost = class {
     this.deps = deps;
   }
   getStatus() {
-    const config2 = loadConfig15(getConfigPath8());
+    const config2 = loadConfig16(getConfigPath8());
     const status = this.deps.remoteCommands.getStatusView();
     const account = this.readAccountView({
       token: normalizeOptionalString4(config2.providers.nextclaw?.apiKey),
@@ -4967,7 +5312,7 @@ var RemoteAccessHost = class {
     };
   }
   async pollBrowserAuth(input) {
-    const config2 = loadConfig15(getConfigPath8());
+    const config2 = loadConfig16(getConfigPath8());
     const result = await this.deps.platformAuthCommands.pollBrowserAuth({
       apiBase: normalizeOptionalString4(input.apiBase) ?? normalizeOptionalString4(config2.remote.platformApiBase) ?? normalizeOptionalString4(config2.providers.nextclaw?.apiBase) ?? void 0,
       sessionId: input.sessionId
@@ -5029,7 +5374,7 @@ var RemoteAccessHost = class {
   }
 };
 
-// src/cli/commands/service-remote-access.ts
+// src/cli/commands/service-support/runtime/service-remote-access.ts
 function requestManagedServiceRestart(requestRestart, options = {}) {
   const uiPort = typeof options.uiPort === "number" && Number.isFinite(options.uiPort) ? Math.floor(options.uiPort) : void 0;
   const reason = options.reason?.trim() || "remote access service restart";
@@ -5077,13 +5422,10 @@ import {
   readAssistantReasoningNormalizationModeFromMetadata,
   writeAssistantReasoningNormalizationModeToMetadata
 } from "@nextclaw/ncp";
-import {
-  createAgentClientFromServer,
-  DefaultNcpAgentBackend
-} from "@nextclaw/ncp-toolkit";
+import { DefaultNcpAgentBackend } from "@nextclaw/ncp-toolkit";
 
-// src/cli/commands/ncp/ncp-asset-tools.ts
-import { resolve as resolve12 } from "path";
+// src/cli/commands/ncp/runtime/ncp-asset-tools.ts
+import { resolve as resolve13 } from "path";
 import {
   buildAssetContentPath
 } from "@nextclaw/ncp-agent-runtime";
@@ -5199,7 +5541,7 @@ var AssetExportTool = class {
     if (!assetUri || !targetPath) {
       throw new Error("asset_export requires assetUri and targetPath.");
     }
-    const exportedPath = await this.assetStore.export({ uri: assetUri }, resolve12(targetPath));
+    const exportedPath = await this.assetStore.export({ uri: assetUri }, resolve13(targetPath));
     return {
       ok: true,
       assetUri,
@@ -5258,10 +5600,12 @@ function createAssetTools(params) {
 import {
   buildToolCatalogEntries,
   ContextBuilder,
+  findEffectiveAgentProfile,
   InputBudgetPruner,
-  getWorkspacePath as getWorkspacePath7,
+  getWorkspacePath as getWorkspacePath8,
   parseThinkingLevel as parseThinkingLevel2,
   readSessionProjectRoot,
+  resolveDefaultAgentProfileId,
   resolveSessionWorkspacePath,
   resolveThinkingLevel
 } from "@nextclaw/core";
@@ -5456,7 +5800,7 @@ function toLegacyMessages(messages, options = {}) {
   return legacyMessages;
 }
 
-// src/cli/commands/ncp/nextclaw-ncp-session-preferences.ts
+// src/cli/commands/ncp/context/nextclaw-ncp-session-preferences.ts
 import { parseThinkingLevel } from "@nextclaw/core";
 function normalizeOptionalString5(value) {
   if (typeof value !== "string") {
@@ -5534,7 +5878,7 @@ function resolveSessionChannelContext(params) {
   return { channel, chatId };
 }
 
-// src/cli/commands/ncp/nextclaw-ncp-current-turn.ts
+// src/cli/commands/ncp/context/nextclaw-ncp-current-turn.ts
 function isTextLikePart2(part) {
   return part.type === "text" || part.type === "rich-text";
 }
@@ -5670,7 +6014,6 @@ var SpawnChildSessionTool = class extends Tool {
   }
   sourceSessionId = "";
   sourceSessionMetadata = {};
-  agentId;
   handoffDepth = 0;
   get name() {
     return "spawn";
@@ -5684,7 +6027,11 @@ var SpawnChildSessionTool = class extends Tool {
       properties: {
         task: { type: "string", description: "Task to run inside the child session." },
         label: { type: "string", description: "Optional child session title." },
-        model: { type: "string", description: "Optional model override for the child session." }
+        model: { type: "string", description: "Optional model override for the child session." },
+        agentId: {
+          type: "string",
+          description: "Optional target agent id for the child session. Omit to use the default agent."
+        }
       },
       required: ["task"]
     };
@@ -5692,7 +6039,6 @@ var SpawnChildSessionTool = class extends Tool {
   setContext = (params) => {
     this.sourceSessionId = params.sourceSessionId;
     this.sourceSessionMetadata = structuredClone(params.sourceSessionMetadata);
-    this.agentId = params.agentId;
     this.handoffDepth = params.handoffDepth ?? 0;
   };
   execute = async (params, toolCallId) => {
@@ -5705,7 +6051,7 @@ var SpawnChildSessionTool = class extends Tool {
       title: readOptionalString2(params, "label"),
       model: readOptionalString2(params, "model"),
       handoffDepth: this.handoffDepth,
-      agentId: this.agentId
+      agentId: readOptionalString2(params, "agentId")
     });
   };
 };
@@ -5809,7 +6155,6 @@ var SessionSpawnTool = class extends Tool2 {
   }
   sourceSessionId = "";
   sourceSessionMetadata = {};
-  agentId;
   get name() {
     return "sessions_spawn";
   }
@@ -5831,6 +6176,10 @@ var SessionSpawnTool = class extends Tool2 {
         model: {
           type: "string",
           description: "Optional model override for the new session."
+        },
+        agentId: {
+          type: "string",
+          description: "Optional target agent id for the new session. Omit to use the default agent."
         }
       },
       required: ["task"]
@@ -5839,7 +6188,6 @@ var SessionSpawnTool = class extends Tool2 {
   setContext = (params) => {
     this.sourceSessionId = params.sourceSessionId;
     this.sourceSessionMetadata = structuredClone(params.sourceSessionMetadata);
-    this.agentId = params.agentId;
   };
   execute = async (params) => {
     const task = readRequiredString2(params.task, "task");
@@ -5847,12 +6195,13 @@ var SessionSpawnTool = class extends Tool2 {
       task,
       title: readOptionalString3(params.title),
       sourceSessionMetadata: this.sourceSessionMetadata,
-      agentId: this.agentId,
+      agentId: readOptionalString3(params.agentId),
       model: readOptionalString3(params.model)
     });
     return {
       kind: "nextclaw.session",
       sessionId: session.sessionId,
+      ...session.agentId ? { agentId: session.agentId } : {},
       ...session.parentSessionId ? { parentSessionId: session.parentSessionId } : {},
       isChildSession: false,
       lifecycle: session.lifecycle,
@@ -5978,7 +6327,6 @@ var NextclawNcpToolRegistry = class {
     spawnTool.setContext({
       sourceSessionId: context.sessionId,
       sourceSessionMetadata: context.metadata,
-      agentId: context.agentId,
       handoffDepth: context.handoffDepth
     });
     this.registerTool(spawnTool);
@@ -5987,8 +6335,7 @@ var NextclawNcpToolRegistry = class {
     );
     sessionsSpawnTool.setContext({
       sourceSessionId: context.sessionId,
-      sourceSessionMetadata: context.metadata,
-      agentId: context.agentId
+      sourceSessionMetadata: context.metadata
     });
     this.registerTool(sessionsSpawnTool);
     const sessionsRequestTool = new SessionRequestTool(
@@ -6128,18 +6475,25 @@ function resolveRequestedToolNames(metadata) {
     )
   );
 }
-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);
+function readRequestedAgentId(metadata) {
+  return normalizeString(metadata.agent_id)?.toLowerCase() ?? normalizeString(metadata.agentId)?.toLowerCase() ?? null;
+}
+function resolveAgentProfile(params) {
+  const defaultAgentId = resolveDefaultAgentProfileId(params.config);
+  const candidateAgentId = normalizeString(params.storedAgentId)?.toLowerCase() ?? readRequestedAgentId(params.requestMetadata) ?? defaultAgentId;
+  const profile = findEffectiveAgentProfile(params.config, candidateAgentId) ?? findEffectiveAgentProfile(params.config, defaultAgentId);
+  if (!profile) {
+    throw new Error(`default agent profile not found: ${defaultAgentId}`);
+  }
   return {
-    agentId: configuredDefaultAgentId,
-    workspace: getWorkspacePath7(profile?.workspace ?? config2.agents.defaults.workspace),
-    model: profile?.model ?? config2.agents.defaults.model,
-    maxIterations: profile?.maxToolIterations ?? config2.agents.defaults.maxToolIterations,
-    contextTokens: profile?.contextTokens ?? config2.agents.defaults.contextTokens,
-    restrictToWorkspace: config2.tools.restrictToWorkspace,
-    searchConfig: config2.search,
-    execTimeoutSeconds: config2.tools.exec.timeout
+    agentId: profile.id,
+    workspace: getWorkspacePath8(profile.workspace ?? params.config.agents.defaults.workspace),
+    model: profile.model ?? params.config.agents.defaults.model,
+    maxIterations: profile.maxToolIterations ?? params.config.agents.defaults.maxToolIterations,
+    contextTokens: profile.contextTokens ?? params.config.agents.defaults.contextTokens,
+    restrictToWorkspace: params.config.tools.restrictToWorkspace,
+    searchConfig: params.config.search,
+    execTimeoutSeconds: params.config.tools.exec.timeout
   };
 }
 function shouldAppendTimeHint(content) {
@@ -6224,9 +6578,13 @@ var NextclawNcpContextBuilder = class {
   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 profile = resolveAgentProfile({
+      config: config2,
+      storedAgentId: session.agentId,
+      requestMetadata
+    });
     let effectiveModel = resolveEffectiveModel({
       session,
       requestMetadata,
@@ -6325,17 +6683,8 @@ var NextclawNcpContextBuilder = class {
   };
 };
 
-// src/cli/commands/ncp/nextclaw-agent-session-store.ts
+// src/cli/commands/ncp/session/nextclaw-agent-session-message-adapter.ts
 import { sanitizeAssistantReplyTags as sanitizeAssistantReplyTags2 } from "@nextclaw/ncp";
-
-// src/cli/commands/ncp/nextclaw-agent-session-metadata.utils.ts
-function resolvePersistedSessionMetadata(params) {
-  const messageMetadata = extractMessageMetadata(params.sessionRecord.messages);
-  const nextMetadata = params.preserveExistingMetadata ? mergeSessionMetadata(params.currentMetadata, messageMetadata) : mergeSessionMetadata({}, messageMetadata);
-  return mergeSessionMetadata(nextMetadata, cloneMetadata(params.sessionRecord.metadata));
-}
-
-// src/cli/commands/ncp/nextclaw-agent-session-store.ts
 function tryParseJson(value) {
   try {
     return JSON.parse(value);
@@ -6587,6 +6936,21 @@ function resolveLegacyEventType(message) {
   }
   return `message.${role || "other"}`;
 }
+
+// src/cli/commands/ncp/session/nextclaw-agent-session-metadata.utils.ts
+function resolvePersistedSessionMetadata(params) {
+  const messageMetadata = extractMessageMetadata(params.sessionRecord.messages);
+  const nextMetadata = params.preserveExistingMetadata ? mergeSessionMetadata(params.currentMetadata, messageMetadata) : mergeSessionMetadata({}, messageMetadata);
+  return mergeSessionMetadata(nextMetadata, cloneMetadata(params.sessionRecord.metadata));
+}
+
+// src/cli/commands/ncp/nextclaw-agent-session-store.ts
+function readAgentIdFromMetadata(metadata) {
+  return normalizeString(metadata?.agent_id)?.toLowerCase() ?? normalizeString(metadata?.agentId)?.toLowerCase() ?? void 0;
+}
+function resolveSessionRecordAgentId(record) {
+  return normalizeString(record.agentId)?.toLowerCase() ?? readAgentIdFromMetadata(record.metadata);
+}
 var NextclawAgentSessionStore = class {
   constructor(sessionManager, options = {}) {
     this.sessionManager = sessionManager;
@@ -6597,7 +6961,13 @@ var NextclawAgentSessionStore = class {
     if (!session) {
       return null;
     }
-    return { sessionId, messages: toNcpMessages(sessionId, session.messages), updatedAt: session.updatedAt.toISOString(), metadata: structuredClone(session.metadata) };
+    return {
+      sessionId,
+      ...session.agentId ? { agentId: session.agentId } : {},
+      messages: toNcpMessages(sessionId, session.messages),
+      updatedAt: session.updatedAt.toISOString(),
+      metadata: structuredClone(session.metadata)
+    };
   };
   listSessions = async () => {
     const records = this.sessionManager.listSessions();
@@ -6611,7 +6981,13 @@ var NextclawAgentSessionStore = class {
       if (!session) {
         continue;
       }
-      sessions.push({ sessionId, messages: toNcpMessages(sessionId, session.messages), updatedAt: session.updatedAt.toISOString(), metadata: structuredClone(session.metadata) });
+      sessions.push({
+        sessionId,
+        ...session.agentId ? { agentId: session.agentId } : {},
+        messages: toNcpMessages(sessionId, session.messages),
+        updatedAt: session.updatedAt.toISOString(),
+        metadata: structuredClone(session.metadata)
+      });
     }
     sessions.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
     return sessions;
@@ -6622,6 +6998,10 @@ var NextclawAgentSessionStore = class {
     }
     const session = this.sessionManager.getIfExists(sessionRecord.sessionId) ?? this.sessionManager.getOrCreate(sessionRecord.sessionId);
     const legacyMessages = toLegacyMessages(sessionRecord.messages);
+    const nextAgentId = resolveSessionRecordAgentId(sessionRecord);
+    if (nextAgentId) {
+      session.agentId = nextAgentId;
+    }
     session.metadata = resolvePersistedSessionMetadata({
       currentMetadata: session.metadata,
       sessionRecord,
@@ -6664,7 +7044,7 @@ var NextclawAgentSessionStore = class {
   };
 };
 
-// src/cli/commands/ncp/provider-manager-ncp-llm-api.ts
+// src/cli/commands/ncp/provider/provider-manager-ncp-llm-api.ts
 import { parseThinkingLevel as parseThinkingLevel3 } from "@nextclaw/core";
 function normalizeModel(value) {
   if (typeof value !== "string") {
@@ -6782,6 +7162,7 @@ var ProviderManagerNcpLLMApi = class {
 };
 
 // src/cli/commands/ncp/session-request/session-creation.service.ts
+import { resolveDefaultAgentProfileId as resolveDefaultAgentProfileId2 } from "@nextclaw/core";
 import { randomUUID } from "crypto";
 var DEFAULT_SESSION_TYPE = "native";
 var DEFAULT_LIFECYCLE = "persistent";
@@ -6827,51 +7208,85 @@ function cloneInheritedMetadata(sourceMetadata) {
   }
   return nextMetadata;
 }
-function buildSessionId(agentId) {
-  void agentId;
+function buildSessionId() {
   return `ncp-${Date.now().toString(36)}-${randomUUID().replace(/-/g, "").slice(0, 8)}`;
 }
+function resolveSessionAgentId(params) {
+  return readOptionalString4(params.agentId) ?? resolveDefaultAgentProfileId2(params.getConfig());
+}
+function resolveSessionTitle(params) {
+  return readOptionalString4(params.title) ?? summarizeTask(params.task);
+}
+function resolveSessionType(params) {
+  return readOptionalString4(params.sessionType) ?? readOptionalString4(params.metadata.session_type) ?? DEFAULT_SESSION_TYPE;
+}
+function applySessionOverrides(params) {
+  params.metadata.session_type = params.sessionType;
+  params.metadata[SESSION_METADATA_LABEL_KEY] = params.title;
+  params.metadata[CHILD_SESSION_LIFECYCLE_METADATA_KEY] = params.lifecycle;
+  if (params.parentSessionId) {
+    params.metadata[CHILD_SESSION_PARENT_METADATA_KEY] = params.parentSessionId;
+    params.metadata[CHILD_SESSION_PROMOTED_METADATA_KEY] = false;
+  }
+  if (params.requestId) {
+    params.metadata[CHILD_SESSION_REQUEST_METADATA_KEY] = params.requestId;
+  }
+  if (readOptionalString4(params.model)) {
+    params.metadata.model = params.model?.trim();
+    params.metadata.preferred_model = params.model?.trim();
+  }
+  if (readOptionalString4(params.thinkingLevel)) {
+    params.metadata.thinking = params.thinkingLevel?.trim();
+    params.metadata.preferred_thinking = params.thinkingLevel?.trim();
+  }
+  if (readOptionalString4(params.projectRoot)) {
+    params.metadata.project_root = params.projectRoot?.trim();
+  }
+}
 var SessionCreationService = class {
-  constructor(sessionManager, onSessionUpdated) {
+  constructor(sessionManager, getConfig, onSessionUpdated) {
     this.sessionManager = sessionManager;
+    this.getConfig = getConfig;
     this.onSessionUpdated = onSessionUpdated;
   }
   createSession = (params) => {
-    const sessionId = buildSessionId(params.agentId);
+    const sessionId = buildSessionId();
     const now3 = (/* @__PURE__ */ new Date()).toISOString();
     const session = this.sessionManager.getOrCreate(sessionId);
-    const title = readOptionalString4(params.title) ?? summarizeTask(params.task);
+    const resolvedAgentId = resolveSessionAgentId({
+      agentId: params.agentId,
+      getConfig: this.getConfig
+    });
+    const title = resolveSessionTitle({
+      title: params.title,
+      task: params.task
+    });
     const metadata = cloneInheritedMetadata(params.sourceSessionMetadata);
     const parentSessionId = readOptionalString4(params.parentSessionId);
     const requestId = readOptionalString4(params.requestId);
-    const sessionType = readOptionalString4(params.sessionType) ?? readOptionalString4(metadata.session_type) ?? DEFAULT_SESSION_TYPE;
-    metadata.session_type = sessionType;
-    metadata[SESSION_METADATA_LABEL_KEY] = title;
-    metadata[CHILD_SESSION_LIFECYCLE_METADATA_KEY] = DEFAULT_LIFECYCLE;
-    if (parentSessionId) {
-      metadata[CHILD_SESSION_PARENT_METADATA_KEY] = parentSessionId;
-      metadata[CHILD_SESSION_PROMOTED_METADATA_KEY] = false;
-    }
-    if (requestId) {
-      metadata[CHILD_SESSION_REQUEST_METADATA_KEY] = requestId;
-    }
-    if (readOptionalString4(params.model)) {
-      metadata.model = params.model?.trim();
-      metadata.preferred_model = params.model?.trim();
-    }
-    if (readOptionalString4(params.thinkingLevel)) {
-      metadata.thinking = params.thinkingLevel?.trim();
-      metadata.preferred_thinking = params.thinkingLevel?.trim();
-    }
-    if (readOptionalString4(params.projectRoot)) {
-      metadata.project_root = params.projectRoot?.trim();
-    }
+    const sessionType = resolveSessionType({
+      sessionType: params.sessionType,
+      metadata
+    });
+    applySessionOverrides({
+      metadata,
+      sessionType,
+      title,
+      lifecycle: DEFAULT_LIFECYCLE,
+      parentSessionId,
+      requestId,
+      model: params.model,
+      thinkingLevel: params.thinkingLevel,
+      projectRoot: params.projectRoot
+    });
+    session.agentId = resolvedAgentId;
     session.metadata = metadata;
     session.updatedAt = new Date(now3);
     this.sessionManager.save(session);
     this.onSessionUpdated?.(sessionId);
     return {
       sessionId,
+      agentId: resolvedAgentId,
       sessionType,
       runtimeFamily: "native",
       ...parentSessionId ? { parentSessionId } : {},
@@ -6910,6 +7325,8 @@ import {
   NcpEventType
 } from "@nextclaw/ncp";
 import { randomUUID as randomUUID2 } from "crypto";
+
+// src/cli/commands/ncp/session-request/session-request-result.ts
 function readOptionalString5(value) {
   if (typeof value !== "string") {
     return null;
@@ -6917,7 +7334,7 @@ function readOptionalString5(value) {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : null;
 }
-function summarizeTask2(task) {
+function summarizeSessionRequestTask(task) {
   const normalized = task.trim().replace(/\s+/g, " ");
   if (!normalized) {
     return "Session request";
@@ -6927,21 +7344,7 @@ function summarizeTask2(task) {
   }
   return `${normalized.slice(0, 69)}...`;
 }
-function buildUserMessage(params) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    id: `${params.sessionId}:user:session-request:${params.requestId}`,
-    sessionId: params.sessionId,
-    role: "user",
-    status: "final",
-    timestamp,
-    parts: [{ type: "text", text: params.task }],
-    metadata: {
-      session_request_id: params.requestId
-    }
-  };
-}
-function extractMessageText(message) {
+function extractSessionMessageText(message) {
   if (!message) {
     return void 0;
   }
@@ -6968,26 +7371,110 @@ function findLatestAssistantMessage(messages) {
 function readParentSessionId(metadata) {
   return readOptionalString5(metadata?.[CHILD_SESSION_PARENT_METADATA_KEY]) ?? void 0;
 }
-function buildToolResult(params) {
+function buildSessionRequestToolResult(params) {
+  const {
+    request,
+    task,
+    title,
+    agentId,
+    isChildSession,
+    parentSessionId,
+    spawnedByRequestId,
+    message
+  } = params;
   return {
     kind: "nextclaw.session_request",
-    requestId: params.request.requestId,
-    sessionId: params.request.targetSessionId,
-    targetKind: params.isChildSession ? "child" : "session",
-    ...params.parentSessionId ? { parentSessionId: params.parentSessionId } : {},
-    ...params.spawnedByRequestId ? { spawnedByRequestId: params.spawnedByRequestId } : {},
-    isChildSession: params.isChildSession,
+    requestId: request.requestId,
+    sessionId: request.targetSessionId,
+    ...agentId ? { agentId } : {},
+    targetKind: isChildSession ? "child" : "session",
+    ...parentSessionId ? { parentSessionId } : {},
+    ...spawnedByRequestId ? { spawnedByRequestId } : {},
+    isChildSession,
     lifecycle: "persistent",
-    ...params.title.trim() ? { title: params.title } : {},
-    task: params.task,
-    status: params.request.status,
-    awaitMode: params.request.awaitMode,
-    deliveryMode: params.request.deliveryMode,
-    ...params.request.finalResponseText ? { finalResponseText: params.request.finalResponseText } : {},
-    ...params.request.error ? { error: params.request.error } : {},
-    ...params.message ? { message: params.message } : {}
+    ...title.trim() ? { title } : {},
+    task,
+    status: request.status,
+    awaitMode: request.awaitMode,
+    deliveryMode: request.deliveryMode,
+    ...request.finalResponseText ? { finalResponseText: request.finalResponseText } : {},
+    ...request.error ? { error: request.error } : {},
+    ...message ? { message } : {}
+  };
+}
+
+// src/cli/commands/ncp/session-request/session-request-execution.ts
+function buildSessionRequestUserMessage(params) {
+  const { sessionId, requestId, task } = params;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: `${sessionId}:user:session-request:${requestId}`,
+    sessionId,
+    role: "user",
+    status: "final",
+    timestamp,
+    parts: [{ type: "text", text: task }],
+    metadata: {
+      session_request_id: requestId
+    }
+  };
+}
+function createRunningSessionRequest(params) {
+  const {
+    requestId,
+    sourceSessionId,
+    targetSessionId,
+    sourceToolCallId,
+    handoffDepth,
+    awaitMode,
+    deliveryMode,
+    title,
+    task,
+    isChildSession,
+    parentSessionId
+  } = params;
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    requestId,
+    sourceSessionId,
+    targetSessionId,
+    sourceToolCallId,
+    rootRequestId: requestId,
+    handoffDepth,
+    awaitMode,
+    deliveryMode,
+    status: "running",
+    createdAt,
+    startedAt: createdAt,
+    metadata: {
+      title,
+      task,
+      is_child_session: isChildSession,
+      ...parentSessionId ? { parent_session_id: parentSessionId } : {}
+    }
+  };
+}
+function createCompletedSessionRequest(params) {
+  const { request, completedMessage, finalResponseText } = params;
+  return {
+    ...request,
+    status: "completed",
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    finalResponseMessageId: completedMessage?.id,
+    finalResponseText
+  };
+}
+function createFailedSessionRequest(params) {
+  const { request, error } = params;
+  return {
+    ...request,
+    status: "failed",
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    error: error instanceof Error ? error.message : String(error)
   };
 }
+
+// src/cli/commands/ncp/session-request/session-request-broker.ts
 var SessionRequestBroker = class {
   constructor(sessionManager, sessionCreationService, deliveryService, resolveBackend, onSessionUpdated) {
     this.sessionManager = sessionManager;
@@ -6997,200 +7484,275 @@ var SessionRequestBroker = class {
     this.onSessionUpdated = onSessionUpdated;
   }
   spawnChildSessionAndRequest = async (params) => {
+    const {
+      sourceSessionId,
+      sourceToolCallId,
+      sourceSessionMetadata,
+      task,
+      title,
+      model,
+      handoffDepth,
+      sessionType,
+      thinkingLevel,
+      projectRoot,
+      agentId
+    } = params;
     const requestId = randomUUID2();
     const childSession = this.sessionCreationService.createChildSession({
-      parentSessionId: params.sourceSessionId,
-      task: params.task,
-      title: params.title,
-      sourceSessionMetadata: params.sourceSessionMetadata,
-      agentId: params.agentId,
-      model: params.model,
-      thinkingLevel: params.thinkingLevel,
-      sessionType: params.sessionType,
-      projectRoot: params.projectRoot,
+      parentSessionId: sourceSessionId,
+      task,
+      title,
+      sourceSessionMetadata,
+      agentId,
+      model,
+      thinkingLevel,
+      sessionType,
+      projectRoot,
       requestId
     });
     return this.dispatchRequest({
       requestId,
-      sourceSessionId: params.sourceSessionId,
-      sourceToolCallId: params.sourceToolCallId,
+      sourceSessionId,
+      sourceToolCallId,
       targetSessionId: childSession.sessionId,
-      task: params.task,
-      title: childSession.title ?? summarizeTask2(params.task),
-      handoffDepth: params.handoffDepth ?? 0,
+      task,
+      title: childSession.title ?? summarizeSessionRequestTask(task),
+      handoffDepth: handoffDepth ?? 0,
       awaitMode: "final_reply",
       deliveryMode: "resume_source",
+      agentId: childSession.agentId,
       isChildSession: true,
-      parentSessionId: params.sourceSessionId,
+      parentSessionId: sourceSessionId,
       spawnedByRequestId: requestId
     });
   };
   requestSession = async (params) => {
-    if (params.targetSessionId.trim() === params.sourceSessionId.trim()) {
+    const {
+      sourceSessionId,
+      sourceToolCallId,
+      targetSessionId,
+      task,
+      title,
+      awaitMode,
+      deliveryMode,
+      handoffDepth
+    } = params;
+    const normalizedTargetSessionId = targetSessionId.trim();
+    if (normalizedTargetSessionId === sourceSessionId.trim()) {
       throw new Error("sessions_request cannot target the current session.");
     }
     const backend = this.resolveBackend();
     if (!backend) {
       throw new Error("NCP backend is not ready for session requests.");
     }
-    const targetSummary = await backend.getSession(params.targetSessionId.trim());
+    const targetSummary = await backend.getSession(normalizedTargetSessionId);
     if (!targetSummary) {
-      throw new Error(`Target session not found: ${params.targetSessionId}`);
+      throw new Error(`Target session not found: ${targetSessionId}`);
     }
     const parentSessionId = readParentSessionId(targetSummary.metadata);
     return this.dispatchRequest({
       requestId: randomUUID2(),
-      sourceSessionId: params.sourceSessionId,
-      sourceToolCallId: params.sourceToolCallId,
-      targetSessionId: params.targetSessionId.trim(),
-      task: params.task,
-      title: readOptionalString5(params.title) ?? readOptionalString5(targetSummary.metadata?.label) ?? summarizeTask2(params.task),
-      handoffDepth: params.handoffDepth ?? 0,
-      awaitMode: params.awaitMode,
-      deliveryMode: params.deliveryMode,
+      sourceSessionId,
+      sourceToolCallId,
+      targetSessionId: normalizedTargetSessionId,
+      task,
+      title: readOptionalString5(title) ?? readOptionalString5(targetSummary.metadata?.label) ?? summarizeSessionRequestTask(task),
+      handoffDepth: handoffDepth ?? 0,
+      awaitMode,
+      deliveryMode,
+      agentId: targetSummary.agentId,
       isChildSession: Boolean(parentSessionId),
       parentSessionId: parentSessionId ?? void 0,
       spawnedByRequestId: void 0
     });
   };
   dispatchRequest = async (params) => {
-    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-    const request = {
-      requestId: params.requestId,
-      sourceSessionId: params.sourceSessionId,
-      targetSessionId: params.targetSessionId,
-      sourceToolCallId: params.sourceToolCallId,
-      rootRequestId: params.requestId,
-      handoffDepth: params.handoffDepth,
-      awaitMode: params.awaitMode,
-      deliveryMode: params.deliveryMode,
-      status: "running",
-      createdAt,
-      startedAt: createdAt,
-      metadata: {
-        title: params.title,
-        task: params.task,
-        is_child_session: params.isChildSession,
-        ...params.parentSessionId ? { parent_session_id: params.parentSessionId } : {}
-      }
-    };
+    const {
+      requestId,
+      sourceSessionId,
+      sourceToolCallId,
+      targetSessionId,
+      task,
+      title,
+      handoffDepth,
+      awaitMode,
+      deliveryMode,
+      agentId,
+      isChildSession,
+      parentSessionId,
+      spawnedByRequestId
+    } = params;
+    const request = createRunningSessionRequest({
+      requestId,
+      sourceSessionId,
+      targetSessionId,
+      sourceToolCallId,
+      handoffDepth,
+      awaitMode,
+      deliveryMode,
+      title,
+      task,
+      isChildSession,
+      parentSessionId
+    });
     void this.runRequest({
       request,
-      task: params.task,
-      title: params.title,
-      isChildSession: params.isChildSession,
-      parentSessionId: params.parentSessionId
+      task,
+      title,
+      agentId,
+      isChildSession,
+      parentSessionId
     }).catch((error) => {
       console.error(
-        `[session-request] Background request ${params.requestId} crashed: ${error instanceof Error ? error.message : String(error)}`
+        `[session-request] Background request ${requestId} crashed: ${error instanceof Error ? error.message : String(error)}`
       );
     });
-    return buildToolResult({
+    return buildSessionRequestToolResult({
       request,
-      task: params.task,
-      title: params.title,
-      isChildSession: params.isChildSession,
-      parentSessionId: params.parentSessionId,
-      spawnedByRequestId: params.spawnedByRequestId,
+      task,
+      title,
+      agentId,
+      isChildSession,
+      parentSessionId,
+      spawnedByRequestId,
       message: `Session request started. You'll receive the final reply when it finishes.`
     });
   };
-  runRequest = async (params) => {
+  resolveBackendOrThrow = () => {
+    const backend = this.resolveBackend();
+    if (!backend) {
+      throw new Error("NCP backend is not ready for session request execution.");
+    }
+    return backend;
+  };
+  readCompletedMessageFromStream = async (params) => {
+    const { backend, request, task } = params;
     let completedMessage;
-    try {
-      const backend = this.resolveBackend();
-      if (!backend) {
-        throw new Error("NCP backend is not ready for session request execution.");
-      }
-      const message = buildUserMessage({
-        sessionId: params.request.targetSessionId,
-        requestId: params.request.requestId,
-        task: params.task
-      });
-      for await (const event of backend.send({
-        sessionId: params.request.targetSessionId,
-        message
-      })) {
-        if (event.type === NcpEventType.MessageAccepted) {
-          this.handleRequestEvent(params.request, event);
-          continue;
-        }
-        if (event.type === NcpEventType.MessageFailed) {
-          throw new Error(event.payload.error.message);
-        }
-        if (event.type === NcpEventType.RunError) {
-          throw new Error(event.payload.error ?? "Session request failed.");
-        }
-        if (event.type === NcpEventType.MessageCompleted) {
-          completedMessage = event.payload.message;
-        }
+    const message = buildSessionRequestUserMessage({
+      sessionId: request.targetSessionId,
+      requestId: request.requestId,
+      task
+    });
+    for await (const event of backend.send({
+      sessionId: request.targetSessionId,
+      message
+    })) {
+      if (event.type === NcpEventType.MessageAccepted) {
+        this.handleRequestEvent(request, event);
+        continue;
       }
-      if (!completedMessage) {
-        const targetMessages = await backend.listSessionMessages(
-          params.request.targetSessionId
-        );
-        completedMessage = findLatestAssistantMessage(targetMessages);
-      }
-      if (!completedMessage) {
-        throw new Error("Session request completed without a final reply.");
-      }
-      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const finalResponseText = extractMessageText(completedMessage);
-      const completedRequest = {
-        ...params.request,
-        status: "completed",
-        completedAt,
-        finalResponseMessageId: completedMessage?.id,
+      if (event.type === NcpEventType.MessageFailed) {
+        throw new Error(event.payload.error.message);
+      }
+      if (event.type === NcpEventType.RunError) {
+        throw new Error(event.payload.error ?? "Session request failed.");
+      }
+      if (event.type === NcpEventType.MessageCompleted) {
+        completedMessage = event.payload.message;
+      }
+    }
+    return completedMessage;
+  };
+  resolveCompletedMessage = async (params) => {
+    const { request, task } = params;
+    const backend = this.resolveBackendOrThrow();
+    const streamedMessage = await this.readCompletedMessageFromStream({
+      backend,
+      request,
+      task
+    });
+    if (streamedMessage) {
+      return streamedMessage;
+    }
+    const targetMessages = await backend.listSessionMessages(
+      request.targetSessionId
+    );
+    const fallbackMessage = findLatestAssistantMessage(targetMessages);
+    if (fallbackMessage) {
+      return fallbackMessage;
+    }
+    throw new Error("Session request completed without a final reply.");
+  };
+  appendRequestEvents = (request, type) => {
+    this.appendRequestEvent(request.sourceSessionId, type, request);
+    this.appendRequestEvent(request.targetSessionId, type, request);
+  };
+  publishRequestOutcome = async (params) => {
+    const {
+      request,
+      task,
+      title,
+      agentId,
+      isChildSession,
+      parentSessionId,
+      spawnedByRequestId
+    } = params;
+    const result = buildSessionRequestToolResult({
+      request,
+      task,
+      title,
+      agentId,
+      isChildSession,
+      parentSessionId,
+      spawnedByRequestId
+    });
+    await this.deliveryService.publishToolResult({
+      request,
+      result
+    });
+    if (request.deliveryMode === "resume_source") {
+      await this.deliveryService.resumeSourceSession({
+        request,
+        result
+      });
+    }
+  };
+  runRequest = async (params) => {
+    const {
+      request,
+      task,
+      title,
+      agentId,
+      isChildSession,
+      parentSessionId,
+      spawnedByRequestId
+    } = params;
+    try {
+      const completedMessage = await this.resolveCompletedMessage({
+        request,
+        task
+      });
+      const finalResponseText = extractSessionMessageText(completedMessage);
+      const completedRequest = createCompletedSessionRequest({
+        request,
+        completedMessage,
         finalResponseText
-      };
-      this.appendRequestEvent(params.request.sourceSessionId, "session.request.completed", completedRequest);
-      this.appendRequestEvent(params.request.targetSessionId, "session.request.completed", completedRequest);
-      const result = buildToolResult({
-        request: completedRequest,
-        task: params.task,
-        title: params.title,
-        isChildSession: params.isChildSession,
-        parentSessionId: params.parentSessionId,
-        spawnedByRequestId: params.spawnedByRequestId
       });
-      await this.deliveryService.publishToolResult({
+      this.appendRequestEvents(completedRequest, "session.request.completed");
+      await this.publishRequestOutcome({
         request: completedRequest,
-        result
+        task,
+        title,
+        agentId,
+        isChildSession,
+        parentSessionId,
+        spawnedByRequestId
       });
-      if (completedRequest.deliveryMode === "resume_source") {
-        await this.deliveryService.resumeSourceSession({
-          request: completedRequest,
-          result
-        });
-      }
     } catch (error) {
-      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const failedRequest = {
-        ...params.request,
-        status: "failed",
-        completedAt,
-        error: error instanceof Error ? error.message : String(error)
-      };
-      this.appendRequestEvent(params.request.sourceSessionId, "session.request.failed", failedRequest);
-      this.appendRequestEvent(params.request.targetSessionId, "session.request.failed", failedRequest);
-      const result = buildToolResult({
-        request: failedRequest,
-        task: params.task,
-        title: params.title,
-        isChildSession: params.isChildSession,
-        parentSessionId: params.parentSessionId,
-        spawnedByRequestId: params.spawnedByRequestId
+      const failedRequest = createFailedSessionRequest({
+        request,
+        error
       });
-      await this.deliveryService.publishToolResult({
+      this.appendRequestEvents(failedRequest, "session.request.failed");
+      await this.publishRequestOutcome({
         request: failedRequest,
-        result
+        task,
+        title,
+        agentId,
+        isChildSession,
+        parentSessionId,
+        spawnedByRequestId
       });
-      if (failedRequest.deliveryMode === "resume_source") {
-        await this.deliveryService.resumeSourceSession({
-          request: failedRequest,
-          result
-        });
-      }
     }
   };
   handleRequestEvent = (request, event) => {
@@ -7240,7 +7802,7 @@ function scheduleDetached(taskFactory, label) {
   }, 0);
 }
 async function sleep(ms) {
-  await new Promise((resolve16) => setTimeout(resolve16, ms));
+  await new Promise((resolve17) => setTimeout(resolve17, ms));
 }
 async function waitForSessionToBecomeIdle(params) {
   const timeoutMs = params.timeoutMs ?? 15e3;
@@ -7428,6 +7990,34 @@ var UiNcpRuntimeRegistry = class {
   }
 };
 
+// src/cli/commands/ncp/runtime/ui-ncp-agent-handle.ts
+import { createAgentClientFromServer } from "@nextclaw/ncp-toolkit";
+function createUiNcpAgentHandle(params) {
+  return {
+    basePath: "/api/ncp/agent",
+    agentClientEndpoint: createAgentClientFromServer(params.backend),
+    streamProvider: params.backend,
+    sessionApi: params.backend,
+    listSessionTypes: (describeParams) => {
+      params.refreshPluginRuntimeRegistrations();
+      return params.runtimeRegistry.listSessionTypes(describeParams);
+    },
+    assetApi: {
+      put: (input) => params.assetStore.putBytes({
+        fileName: input.fileName,
+        mimeType: input.mimeType,
+        bytes: input.bytes,
+        createdAt: input.createdAt
+      }),
+      stat: (uri) => params.assetStore.statRecord(uri),
+      resolveContentPath: (uri) => params.assetStore.resolveContentPath(uri)
+    },
+    applyExtensionRegistry: params.applyExtensionRegistry,
+    applyMcpConfig: params.applyMcpConfig,
+    dispose: params.dispose
+  };
+}
+
 // src/cli/commands/ncp/create-ui-ncp-agent.ts
 import { join as join5 } from "path";
 var CODEX_RUNTIME_KIND = "codex";
@@ -7617,31 +8207,6 @@ var PluginRuntimeRegistrationController = class {
     this.pluginRuntimeSnapshotKey = "";
   };
 };
-function createUiNcpAgentHandle(params) {
-  return {
-    basePath: "/api/ncp/agent",
-    agentClientEndpoint: createAgentClientFromServer(params.backend),
-    streamProvider: params.backend,
-    sessionApi: params.backend,
-    listSessionTypes: (describeParams) => {
-      params.refreshPluginRuntimeRegistrations();
-      return params.runtimeRegistry.listSessionTypes(describeParams);
-    },
-    assetApi: {
-      put: (input) => params.assetStore.putBytes({
-        fileName: input.fileName,
-        mimeType: input.mimeType,
-        bytes: input.bytes,
-        createdAt: input.createdAt
-      }),
-      stat: (uri) => params.assetStore.statRecord(uri),
-      resolveContentPath: (uri) => params.assetStore.resolveContentPath(uri)
-    },
-    applyExtensionRegistry: params.applyExtensionRegistry,
-    applyMcpConfig: params.applyMcpConfig,
-    dispose: params.dispose
-  };
-}
 async function createUiNcpAgent(params) {
   const sessionStore = new NextclawAgentSessionStore(params.sessionManager, {
     onSessionUpdated: params.onSessionUpdated
@@ -7654,6 +8219,7 @@ async function createUiNcpAgent(params) {
   let backend = null;
   const sessionCreationService = new SessionCreationService(
     params.sessionManager,
+    params.getConfig,
     params.onSessionUpdated
   );
   const sessionRequestBroker = new SessionRequestBroker(
@@ -7705,7 +8271,7 @@ async function createUiNcpAgent(params) {
   });
 }
 
-// src/cli/commands/service-gateway-context.ts
+// src/cli/commands/service-support/gateway/service-gateway-context.ts
 import * as NextclawCore from "@nextclaw/core";
 import { getPluginChannelBindings as getPluginChannelBindings3, resolvePluginChannelMessageToolHints } from "@nextclaw/openclaw-compat";
 import { join as join6 } from "path";
@@ -8169,14 +8735,16 @@ var ConfigReloader = class {
   }
 };
 
-// src/cli/commands/agent-runtime-pool.ts
+// src/cli/commands/agent/agent-runtime-pool.ts
 import {
   NativeAgentEngine,
   CommandRegistry,
   createAssistantStreamDeltaControlMessage,
   createAssistantStreamResetControlMessage,
   AgentRouteResolver,
-  getWorkspacePath as getWorkspacePath8,
+  getWorkspacePath as getWorkspacePath9,
+  resolveDefaultAgentProfileId as resolveDefaultAgentProfileId3,
+  resolveEffectiveAgentProfiles as resolveEffectiveAgentProfiles2,
   parseAgentScopedSessionKey
 } from "@nextclaw/core";
 function normalizeAgentId(value) {
@@ -8198,33 +8766,21 @@ function toRecord(value) {
 }
 function resolveAgentProfiles(config2) {
   const defaults = config2.agents.defaults;
-  const listed = Array.isArray(config2.agents.list) ? config2.agents.list.map((entry) => ({
-    id: normalizeAgentId(entry.id),
-    default: entry.default,
-    workspace: entry.workspace,
-    model: entry.model,
-    engine: entry.engine,
-    engineConfig: toRecord(entry.engineConfig),
-    maxToolIterations: entry.maxToolIterations,
-    contextTokens: entry.contextTokens
-  })).filter((entry) => Boolean(entry.id)) : [];
-  const defaultAgentId = listed.find((entry) => entry.default)?.id ?? listed[0]?.id ?? "main";
-  const seed = listed.length > 0 ? listed : [{ id: defaultAgentId }];
+  const defaultAgentId = normalizeAgentId(resolveDefaultAgentProfileId3(config2));
+  const listed = resolveEffectiveAgentProfiles2(config2);
+  const seed = listed.length > 0 ? listed : [{ id: defaultAgentId, workspace: defaults.workspace }];
   const unique = /* @__PURE__ */ new Map();
   for (const entry of seed) {
     if (!unique.has(entry.id)) {
       unique.set(entry.id, entry);
     }
   }
-  if (!unique.has(defaultAgentId)) {
-    unique.set(defaultAgentId, { id: defaultAgentId });
-  }
   return Array.from(unique.values()).map((entry) => ({
     id: entry.id,
-    workspace: getWorkspacePath8(entry.workspace ?? defaults.workspace),
+    workspace: getWorkspacePath9(entry.workspace),
     model: entry.model ?? defaults.model,
     engine: normalizeEngineKind(entry.engine ?? defaults.engine),
-    engineConfig: entry.engineConfig ?? toRecord(defaults.engineConfig),
+    engineConfig: toRecord(entry.engineConfig) ?? toRecord(defaults.engineConfig),
     maxIterations: entry.maxToolIterations ?? defaults.maxToolIterations,
     contextTokens: entry.contextTokens ?? defaults.contextTokens
   }));
@@ -8489,7 +9045,7 @@ var GatewayAgentRuntimePool = class {
     const normalizedAgentId = normalizeAgentId(agentId);
     return this.resolvedProfiles.find((profile) => profile.id === normalizedAgentId) ?? this.resolvedProfiles.find((profile) => profile.id === this.defaultAgentId) ?? this.resolvedProfiles[0] ?? {
       id: this.defaultAgentId,
-      workspace: getWorkspacePath8(this.options.config.agents.defaults.workspace),
+      workspace: getWorkspacePath9(this.options.config.agents.defaults.workspace),
       model: this.options.config.agents.defaults.model,
       maxIterations: this.options.config.agents.defaults.maxToolIterations,
       contextTokens: this.options.config.agents.defaults.contextTokens,
@@ -8666,7 +9222,7 @@ function formatUserFacingError(error, maxChars = 320) {
   return `${normalized.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
 }
 
-// src/cli/commands/service-cron-job-handler.ts
+// src/cli/commands/service-support/gateway/service-cron-job-handler.ts
 function normalizeOptionalString6(value) {
   if (typeof value !== "string") {
     return void 0;
@@ -8684,13 +9240,14 @@ function createCronJobHandler(params) {
   return async (job) => {
     const accountId = normalizeOptionalString6(job.payload.accountId);
     const metadata = buildCronJobMetadata(accountId);
+    const agentId = normalizeOptionalString6(job.payload.agentId) ?? params.runtimePool.primaryAgentId;
     const response = await params.runtimePool.processDirect({
       content: job.payload.message,
       sessionKey: `cron:${job.id}`,
       channel: job.payload.channel ?? "cli",
       chatId: job.payload.to ?? "direct",
       metadata,
-      agentId: params.runtimePool.primaryAgentId
+      agentId
     });
     if (job.payload.deliver && job.payload.to) {
       await params.bus.publishOutbound({
@@ -8705,15 +9262,15 @@ function createCronJobHandler(params) {
   };
 }
 
-// src/cli/commands/service-gateway-context.ts
+// src/cli/commands/service-support/gateway/service-gateway-context.ts
 var {
   ChannelManager: ChannelManager2,
   CronService: CronService2,
   getConfigPath: getConfigPath9,
   getDataDir: getDataDir8,
-  getWorkspacePath: getWorkspacePath9,
+  getWorkspacePath: getWorkspacePath10,
   HeartbeatService,
-  loadConfig: loadConfig16,
+  loadConfig: loadConfig17,
   MessageBus,
   ProviderManager,
   resolveConfigSecrets: resolveConfigSecrets2,
@@ -8727,8 +9284,8 @@ function applyGatewayCapabilityState(gateway, next) {
 }
 function createGatewayShellContext(params) {
   const runtimeConfigPath = getConfigPath9();
-  const config2 = resolveConfigSecrets2(loadConfig16(), { configPath: runtimeConfigPath });
-  const workspace = getWorkspacePath9(config2.agents.defaults.workspace);
+  const config2 = resolveConfigSecrets2(loadConfig17(), { configPath: runtimeConfigPath });
+  const workspace = getWorkspacePath10(config2.agents.defaults.workspace);
   const cronStorePath = join6(getDataDir8(), "cron", "jobs.json");
   const sessionManager = measureStartupSync(
     "service.gateway_shell_context.session_manager",
@@ -8738,7 +9295,7 @@ function createGatewayShellContext(params) {
   const uiConfig = resolveUiConfig(config2, params.uiOverrides);
   const uiStaticDir = params.uiStaticDir === void 0 ? resolveUiStaticDir() : params.uiStaticDir;
   const remoteModule = createManagedRemoteModuleForUi({
-    loadConfig: () => resolveConfigSecrets2(loadConfig16(), { configPath: runtimeConfigPath }),
+    loadConfig: () => resolveConfigSecrets2(loadConfig17(), { configPath: runtimeConfigPath }),
     uiConfig
   });
   return {
@@ -8808,7 +9365,7 @@ function createGatewayStartupContext(params) {
       sessionManager: state.sessionManager,
       providerManager: state.providerManager,
       makeProvider: (nextConfig) => params.makeProvider(nextConfig, { allowMissing: true }) ?? params.makeMissingProvider(nextConfig),
-      loadConfig: () => resolveConfigSecrets2(loadConfig16(), { configPath: state.runtimeConfigPath }),
+      loadConfig: () => resolveConfigSecrets2(loadConfig17(), { configPath: state.runtimeConfigPath }),
       resolveChannelConfig: (nextConfig) => resolveChannelConfigView(nextConfig, state.pluginChannelBindings),
       getExtensionChannels: () => state.extensionRegistry.channels,
       onRestartRequired: (paths) => {
@@ -8821,7 +9378,7 @@ function createGatewayStartupContext(params) {
     })
   );
   state.applyLiveConfigReload = async () => {
-    await state.reloader.applyReloadPlan(resolveConfigSecrets2(loadConfig16(), { configPath: state.runtimeConfigPath }));
+    await state.reloader.applyReloadPlan(resolveConfigSecrets2(loadConfig17(), { configPath: state.runtimeConfigPath }));
   };
   state.gatewayController = measureStartupSync(
     "service.gateway_context.gateway_controller",
@@ -8859,7 +9416,7 @@ function createGatewayStartupContext(params) {
       resolveMessageToolHints: ({ channel, accountId }) => resolvePluginChannelMessageToolHints({
         registry: state.pluginRegistry,
         channel,
-        cfg: resolveConfigSecrets2(loadConfig16(), { configPath: state.runtimeConfigPath }),
+        cfg: resolveConfigSecrets2(loadConfig17(), { configPath: state.runtimeConfigPath }),
         accountId
       })
     })
@@ -8878,12 +9435,12 @@ function createGatewayStartupContext(params) {
   return state;
 }
 
-// src/cli/commands/service-gateway-startup.ts
+// src/cli/commands/service-support/gateway/service-gateway-startup.ts
 import {
   startUiServer
 } from "@nextclaw/server";
 
-// src/cli/commands/service-deferred-ncp-agent.ts
+// src/cli/commands/service-support/session/service-deferred-ncp-agent.ts
 var DEFAULT_BASE_PATH = "/api/ncp/agent";
 var DEFERRED_NCP_AGENT_UNAVAILABLE = "ncp agent unavailable during startup";
 function createUnavailableError() {
@@ -8979,7 +9536,7 @@ function createDeferredUiNcpAgent(basePath = DEFAULT_BASE_PATH) {
   return new DeferredUiNcpAgentControllerOwner(basePath);
 }
 
-// src/cli/commands/service-gateway-startup.ts
+// src/cli/commands/service-support/gateway/service-gateway-startup.ts
 function wireSystemSessionUpdatedPublisher(params) {
   params.runtimePool.setSystemSessionUpdatedHandler(({ sessionKey }) => {
     params.publishUiEvent?.({
@@ -9002,6 +9559,7 @@ async function startUiShell(params) {
     productVersion: params.productVersion,
     staticDir: params.uiStaticDir ?? void 0,
     applyLiveConfigReload: params.applyLiveConfigReload,
+    initializeAgentHomeDirectory: params.initializeAgentHomeDirectory,
     cronService: params.cronService,
     marketplace: params.marketplace,
     remoteAccess: params.remoteAccess,
@@ -9087,7 +9645,7 @@ async function runGatewayRuntimeLoop(params) {
   }
 }
 
-// src/cli/commands/ncp/ncp-session-realtime-change.ts
+// src/cli/commands/ncp/session/ncp-session-realtime-change.ts
 function toNcpSessionRealtimeEvent(change) {
   if (change.kind === "upsert") {
     return {
@@ -9127,10 +9685,11 @@ function createNcpSessionRealtimeChangePublisher(params) {
   };
 }
 
-// src/cli/commands/ncp/ncp-session-summary.ts
+// src/cli/commands/ncp/session/ncp-session-summary.ts
 function createNcpSessionSummary(params) {
   return {
     sessionId: params.sessionId,
+    ...params.agentId ? { agentId: params.agentId } : {},
     messageCount: params.messages.length,
     updatedAt: params.updatedAt,
     status: params.status,
@@ -9170,6 +9729,7 @@ var UiSessionService = class {
       sessions.map(
         (session) => createNcpSessionSummary({
           sessionId: session.sessionId,
+          agentId: session.agentId,
           messages: session.messages,
           updatedAt: session.updatedAt,
           status: "idle",
@@ -9193,6 +9753,7 @@ var UiSessionService = class {
     }
     return createNcpSessionSummary({
       sessionId,
+      agentId: session.agentId,
       messages: session.messages,
       updatedAt: session.updatedAt,
       status: "idle",
@@ -9217,7 +9778,7 @@ var UiSessionService = class {
   };
 };
 
-// src/cli/commands/service-deferred-ncp-session-service.ts
+// src/cli/commands/service-support/session/service-deferred-ncp-session-service.ts
 function createDeferredUiNcpSessionService(fallbackService) {
   let activeService = null;
   const resolveService = () => activeService ?? fallbackService;
@@ -9242,7 +9803,7 @@ function createDeferredUiNcpSessionService(fallbackService) {
   };
 }
 
-// src/cli/commands/service-ncp-session-realtime-bridge.ts
+// src/cli/commands/service-support/session/service-ncp-session-realtime-bridge.ts
 function createLatestOnlySessionChangePublisher(publishSessionChange) {
   const inFlightTasks = /* @__PURE__ */ new Map();
   const rerunKeys = /* @__PURE__ */ new Set();
@@ -9305,7 +9866,7 @@ function createServiceNcpSessionRealtimeBridge(params) {
   };
 }
 
-// src/cli/commands/plugin-registry-loader.ts
+// src/cli/commands/plugin/plugin-registry-loader.ts
 import {
   discoverPluginStatusReport,
   loadOpenClawPluginsProgressively
@@ -9357,14 +9918,14 @@ function createEmptyPluginRegistry() {
   };
 }
 
-// src/cli/commands/service-gateway-bootstrap.ts
+// src/cli/commands/service-support/gateway/service-gateway-bootstrap.ts
 import * as NextclawCore2 from "@nextclaw/core";
 import {
   getPluginUiMetadataFromRegistry as getPluginUiMetadataFromRegistry2,
   startPluginChannelGateways as startPluginChannelGateways2
 } from "@nextclaw/openclaw-compat";
 
-// src/cli/commands/service-bootstrap-status.ts
+// src/cli/commands/service-support/gateway/service-bootstrap-status.ts
 function now2() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -9488,14 +10049,14 @@ var ServiceBootstrapStatusStore = class {
   }
 };
 
-// src/cli/commands/service-capability-hydration.ts
-import { getWorkspacePath as getWorkspacePath10, loadConfig as loadConfig17, resolveConfigSecrets as resolveConfigSecrets3 } from "@nextclaw/core";
+// src/cli/commands/service-support/gateway/service-capability-hydration.ts
+import { getWorkspacePath as getWorkspacePath11, loadConfig as loadConfig18, resolveConfigSecrets as resolveConfigSecrets3 } from "@nextclaw/core";
 import {
   getPluginChannelBindings as getPluginChannelBindings4,
   getPluginUiMetadataFromRegistry
 } from "@nextclaw/openclaw-compat";
 
-// src/cli/commands/plugin-reload.ts
+// src/cli/commands/plugin/plugin-reload.ts
 function buildPluginChannelBindingSignature(binding) {
   return `${binding.pluginId}:${binding.channelId}`;
 }
@@ -9568,7 +10129,7 @@ function shouldRestartChannelsForPluginReload(params) {
   return false;
 }
 
-// src/cli/commands/service-ui-shell-grace.ts
+// src/cli/commands/service-support/gateway/service-ui-shell-grace.ts
 import { setTimeout as delay } from "timers/promises";
 var DEFAULT_UI_SHELL_GRACE_MS = 3e3;
 async function waitForUiShellGraceWindow(uiStartup) {
@@ -9580,14 +10141,14 @@ async function waitForUiShellGraceWindow(uiStartup) {
   });
 }
 
-// src/cli/commands/service-capability-hydration.ts
+// src/cli/commands/service-support/gateway/service-capability-hydration.ts
 function countEnabledPlugins(config2, workspaceDir) {
   return discoverPluginRegistryStatus(config2, workspaceDir).plugins.filter((plugin) => plugin.enabled).length;
 }
 async function hydrateServiceCapabilities(params) {
   await waitForUiShellGraceWindow(params.uiStartup);
-  const nextConfig = resolveConfigSecrets3(loadConfig17(), { configPath: params.gateway.runtimeConfigPath });
-  const nextWorkspace = getWorkspacePath10(nextConfig.agents.defaults.workspace);
+  const nextConfig = resolveConfigSecrets3(loadConfig18(), { configPath: params.gateway.runtimeConfigPath });
+  const nextWorkspace = getWorkspacePath11(nextConfig.agents.defaults.workspace);
   const totalPluginCount = countEnabledPlugins(nextConfig, nextWorkspace);
   let loadedPluginCount = 0;
   params.bootstrapStatus.markPluginHydrationRunning({
@@ -9643,18 +10204,18 @@ async function hydrateServiceCapabilities(params) {
   }
 }
 
-// src/cli/commands/service-plugin-runtime-bridge.ts
-import { loadConfig as loadConfig18, resolveConfigSecrets as resolveConfigSecrets4, saveConfig as saveConfig10 } from "@nextclaw/core";
+// src/cli/commands/service-support/plugin/service-plugin-runtime-bridge.ts
+import { loadConfig as loadConfig19, resolveConfigSecrets as resolveConfigSecrets4, saveConfig as saveConfig10 } from "@nextclaw/core";
 import { setPluginRuntimeBridge } from "@nextclaw/openclaw-compat";
 function installPluginRuntimeBridge(params) {
   const { runtimePool, runtimeConfigPath, getPluginChannelBindings: getPluginChannelBindings7 } = params;
   setPluginRuntimeBridge({
-    loadConfig: () => toPluginConfigView(resolveConfigSecrets4(loadConfig18(), { configPath: runtimeConfigPath }), getPluginChannelBindings7()),
+    loadConfig: () => toPluginConfigView(resolveConfigSecrets4(loadConfig19(), { configPath: runtimeConfigPath }), getPluginChannelBindings7()),
     writeConfigFile: async (nextConfigView) => {
       if (!nextConfigView || typeof nextConfigView !== "object" || Array.isArray(nextConfigView)) {
         throw new Error("plugin runtime writeConfigFile expects an object config");
       }
-      const current = loadConfig18();
+      const current = loadConfig19();
       const next = mergePluginConfigView(current, nextConfigView, getPluginChannelBindings7());
       saveConfig10(next);
     },
@@ -9759,15 +10320,15 @@ function resolvePluginRuntimeAttachments(ctx) {
   return attachments;
 }
 
-// src/cli/commands/service-plugin-reload.ts
-import { getWorkspacePath as getWorkspacePath11 } from "@nextclaw/core";
+// src/cli/commands/service-support/plugin/service-plugin-reload.ts
+import { getWorkspacePath as getWorkspacePath12 } from "@nextclaw/core";
 import {
   getPluginChannelBindings as getPluginChannelBindings5,
   startPluginChannelGateways,
   stopPluginChannelGateways
 } from "@nextclaw/openclaw-compat";
 async function reloadServicePlugins(params) {
-  const nextWorkspace = getWorkspacePath11(params.nextConfig.agents.defaults.workspace);
+  const nextWorkspace = getWorkspacePath12(params.nextConfig.agents.defaults.workspace);
   const nextPluginRegistry = loadPluginRegistry(params.nextConfig, nextWorkspace);
   const nextExtensionRegistry = toExtensionRegistry(nextPluginRegistry);
   const nextPluginChannelBindings = getPluginChannelBindings5(nextPluginRegistry);
@@ -9799,8 +10360,8 @@ async function reloadServicePlugins(params) {
   };
 }
 
-// src/cli/commands/service-gateway-bootstrap.ts
-var { loadConfig: loadConfig19, resolveConfigSecrets: resolveConfigSecrets5 } = NextclawCore2;
+// src/cli/commands/service-support/gateway/service-gateway-bootstrap.ts
+var { loadConfig: loadConfig20, resolveConfigSecrets: resolveConfigSecrets5 } = NextclawCore2;
 function createBootstrapStatus(remoteEnabled) {
   const bootstrapStatus = new ServiceBootstrapStatusStore();
   bootstrapStatus.markPluginHydrationPending();
@@ -9878,7 +10439,7 @@ function createDeferredGatewayStartupHooks(params) {
     startPluginGateways: async () => {
       const startedPluginGateways = await startPluginChannelGateways2({
         registry: params.state.pluginRegistry,
-        config: resolveConfigSecrets5(loadConfig19(), { configPath: params.gateway.runtimeConfigPath }),
+        config: resolveConfigSecrets5(loadConfig20(), { configPath: params.gateway.runtimeConfigPath }),
         logger: pluginGatewayLogger
       });
       params.state.pluginGatewayHandles = startedPluginGateways.handles;
@@ -9909,9 +10470,9 @@ var {
   getConfigPath: getConfigPath10,
   getProvider,
   getProviderName,
-  getWorkspacePath: getWorkspacePath12,
+  getWorkspacePath: getWorkspacePath13,
   LiteLLMProvider,
-  loadConfig: loadConfig20,
+  loadConfig: loadConfig21,
   MessageBus: MessageBus2,
   resolveConfigSecrets: resolveConfigSecrets6,
   SessionManager: SessionManager2,
@@ -9930,7 +10491,7 @@ var ServiceCommands = class {
   }
   applyLiveConfigReload = null;
   liveUiNcpAgent = null;
-  async startGateway(options = {}) {
+  startGateway = async (options = {}) => {
     logStartupTrace("service.start_gateway.begin");
     this.applyLiveConfigReload = null;
     this.liveUiNcpAgent = null;
@@ -9952,7 +10513,7 @@ var ServiceCommands = class {
         uiConfig: shellContext.uiConfig,
         uiStaticDir: shellContext.uiStaticDir,
         cronService: shellContext.cron,
-        getConfig: () => resolveConfigSecrets6(loadConfig20(), { configPath: shellContext.runtimeConfigPath }),
+        getConfig: () => resolveConfigSecrets6(loadConfig21(), { configPath: shellContext.runtimeConfigPath }),
         configPath: getConfigPath10(),
         productVersion: getPackageVersion(),
         getPluginChannelBindings: () => runtimeState?.pluginChannelBindings ?? [],
@@ -9962,7 +10523,8 @@ var ServiceCommands = class {
         getBootstrapStatus: () => bootstrapStatus.getStatus(),
         openBrowserWindow: shellContext.uiConfig.open,
         applyLiveConfigReload,
-        ncpSessionService: ncpSessionRealtimeBridge.sessionService
+        ncpSessionService: ncpSessionRealtimeBridge.sessionService,
+        initializeAgentHomeDirectory: this.deps.initializeAgentHomeDirectory
       })
     );
     ncpSessionRealtimeBridge.setUiEventPublisher(uiStartup?.publish);
@@ -9999,7 +10561,7 @@ var ServiceCommands = class {
         startHeartbeat: () => gateway.heartbeat.start()
       })
     );
-    watchCronStoreFile({ cronStorePath: resolve13(join7(NextclawCore3.getDataDir(), "cron", "jobs.json")), reloadCronStore: () => gateway.cron.reloadFromStore() });
+    watchCronStoreFile({ cronStorePath: resolve14(join7(NextclawCore3.getDataDir(), "cron", "jobs.json")), reloadCronStore: () => gateway.cron.reloadFromStore() });
     const deferredGatewayStartupHooks = createDeferredGatewayStartupHooks({
       uiStartup,
       gateway,
@@ -10022,12 +10584,12 @@ var ServiceCommands = class {
         providerManager: gateway.providerManager,
         cronService: gateway.cron,
         gatewayController: gateway.gatewayController,
-        getConfig: () => resolveConfigSecrets6(loadConfig20(), { configPath: gateway.runtimeConfigPath }),
+        getConfig: () => resolveConfigSecrets6(loadConfig21(), { configPath: gateway.runtimeConfigPath }),
         getExtensionRegistry: () => gatewayRuntimeState.extensionRegistry,
         resolveMessageToolHints: ({ channel, accountId }) => resolvePluginChannelMessageToolHints2({
           registry: gatewayRuntimeState.pluginRegistry,
           channel,
-          cfg: resolveConfigSecrets6(loadConfig20(), { configPath: gateway.runtimeConfigPath }),
+          cfg: resolveConfigSecrets6(loadConfig21(), { configPath: gateway.runtimeConfigPath }),
           accountId
         }),
         hydrateCapabilities: deferredGatewayStartupHooks.hydrateCapabilities,
@@ -10056,22 +10618,22 @@ var ServiceCommands = class {
       }
     });
     logStartupTrace("service.start_gateway.end");
-  }
-  normalizeOptionalString(value) {
+  };
+  normalizeOptionalString = (value) => {
     if (typeof value !== "string") {
       return void 0;
     }
     const trimmed = value.trim();
     return trimmed || void 0;
-  }
-  watchConfigFile(reloader) {
-    const configPath = resolve13(getConfigPath10());
+  };
+  watchConfigFile = (reloader) => {
+    const configPath = resolve14(getConfigPath10());
     const watcher = chokidar2.watch(configPath, {
       ignoreInitial: true,
       awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
     });
     watcher.on("all", (event, changedPath) => {
-      if (resolve13(changedPath) !== configPath) {
+      if (resolve14(changedPath) !== configPath) {
         return;
       }
       if (event === "add") {
@@ -10086,34 +10648,24 @@ var ServiceCommands = class {
         reloader.scheduleReload("config unlink");
       }
     });
-  }
-  resolveMostRecentRoutableSessionKey(sessionManager) {
-    const sessions = sessionManager.listSessions();
+  };
+  resolveMostRecentRoutableSessionKey = (sessionManager) => {
     let best = null;
-    for (const session of sessions) {
-      const key = this.normalizeOptionalString(session.key);
-      if (!key || key.startsWith("cli:")) {
-        continue;
-      }
-      const metadataRaw = session.metadata;
-      const metadata = metadataRaw && typeof metadataRaw === "object" && !Array.isArray(metadataRaw) ? metadataRaw : {};
-      const contextRaw = metadata.last_delivery_context;
-      const context = contextRaw && typeof contextRaw === "object" && !Array.isArray(contextRaw) ? contextRaw : {};
-      const hasRoute = Boolean(this.normalizeOptionalString(context.channel)) && Boolean(this.normalizeOptionalString(context.chatId));
-      const hasFallbackRoute = Boolean(this.normalizeOptionalString(metadata.last_channel)) && Boolean(this.normalizeOptionalString(metadata.last_to));
-      if (!hasRoute && !hasFallbackRoute) {
+    for (const session of sessionManager.listSessions()) {
+      const candidate = resolveSessionRouteCandidate({
+        session,
+        normalizeOptionalString: (value) => this.normalizeOptionalString(value)
+      });
+      if (!candidate) {
         continue;
       }
-      const updatedAtRaw = this.normalizeOptionalString(session.updated_at);
-      const updatedAt = updatedAtRaw ? Date.parse(updatedAtRaw) : Number.NaN;
-      const score = Number.isFinite(updatedAt) ? updatedAt : 0;
-      if (!best || score >= best.updatedAt) {
-        best = { key, updatedAt: score };
+      if (!best || candidate.updatedAt >= best.updatedAt) {
+        best = candidate;
       }
     }
     return best?.key;
-  }
-  buildRestartWakePrompt(params) {
+  };
+  buildRestartWakePrompt = (params) => {
     const lines = [
       "System event: the gateway has restarted successfully.",
       "Please send one short confirmation to the user that you are back online.",
@@ -10134,13 +10686,13 @@ var ServiceCommands = class {
       lines.push(`Reply target message id: ${replyTo}. If suitable, include [[reply_to:${replyTo}]].`);
     }
     return lines.join("\n");
-  }
-  async wakeFromRestartSentinel(params) {
+  };
+  wakeFromRestartSentinel = async (params) => {
     const sentinel = await consumeRestartSentinel();
     if (!sentinel) {
       return;
     }
-    await new Promise((resolve16) => setTimeout(resolve16, 750));
+    await new Promise((resolve17) => setTimeout(resolve17, 750));
     const payload = sentinel.payload;
     const summary = formatRestartSentinelMessage(payload);
     const sentinelSessionKey = this.normalizeOptionalString(payload.sessionKey);
@@ -10184,9 +10736,9 @@ var ServiceCommands = class {
       attachments: [],
       metadata
     });
-  }
-  async runForeground(options) {
-    const config2 = loadConfig20();
+  };
+  runForeground = async (options) => {
+    const config2 = loadConfig21();
     const uiConfig = resolveUiConfig(config2, options.uiOverrides);
     const uiUrl = resolveUiApiBase(uiConfig.host, uiConfig.port);
     if (options.open) {
@@ -10197,48 +10749,39 @@ var ServiceCommands = class {
       allowMissingProvider: true,
       uiStaticDir: resolveUiStaticDir()
     });
-  }
-  async startService(options) {
-    const config2 = loadConfig20();
+  };
+  handleExistingManagedService = async (params) => {
+    console.log(`\u2713 ${APP_NAME3} is already running (PID ${params.existing.pid})`);
+    console.log(`UI: ${params.existing.uiUrl}`);
+    console.log(`API: ${params.existing.apiUrl}`);
+    const binding = resolveManagedServiceUiBinding(params.existing);
+    if (binding.host !== params.uiConfig.host || binding.port !== params.uiConfig.port) {
+      console.log(
+        `Detected running service UI bind (${binding.host}:${binding.port}); enforcing (${params.uiConfig.host}:${params.uiConfig.port})...`
+      );
+      await this.stopService();
+      const stateAfterStop = readServiceState();
+      if (stateAfterStop && isProcessRunning(stateAfterStop.pid)) {
+        console.error("Error: Failed to stop running service while enforcing public UI exposure.");
+        return true;
+      }
+      await this.startService(params.options);
+      return true;
+    }
+    await this.printPublicUiUrls(binding.host, binding.port);
+    console.log(`Logs: ${params.existing.logPath}`);
+    this.printServiceControlHints();
+    return true;
+  };
+  startService = async (options) => {
+    const config2 = loadConfig21();
     const uiConfig = resolveUiConfig(config2, options.uiOverrides);
     const uiUrl = resolveUiApiBase(uiConfig.host, uiConfig.port);
     const apiUrl = `${uiUrl}/api`;
     const staticDir = resolveUiStaticDir();
     const existing = readServiceState();
     if (existing && isProcessRunning(existing.pid)) {
-      console.log(`\u2713 ${APP_NAME3} is already running (PID ${existing.pid})`);
-      console.log(`UI: ${existing.uiUrl}`);
-      console.log(`API: ${existing.apiUrl}`);
-      const parsedUi = (() => {
-        try {
-          const parsed = new URL(existing.uiUrl);
-          const port = Number(parsed.port || 80);
-          return {
-            host: existing.uiHost ?? parsed.hostname,
-            port: Number.isFinite(port) ? port : existing.uiPort ?? 55667
-          };
-        } catch {
-          return {
-            host: existing.uiHost ?? "127.0.0.1",
-            port: existing.uiPort ?? 55667
-          };
-        }
-      })();
-      if (parsedUi.host !== uiConfig.host || parsedUi.port !== uiConfig.port) {
-        console.log(
-          `Detected running service UI bind (${parsedUi.host}:${parsedUi.port}); enforcing (${uiConfig.host}:${uiConfig.port})...`
-        );
-        await this.stopService();
-        const stateAfterStop = readServiceState();
-        if (stateAfterStop && isProcessRunning(stateAfterStop.pid)) {
-          console.error("Error: Failed to stop running service while enforcing public UI exposure.");
-          return;
-        }
-        return this.startService(options);
-      }
-      await this.printPublicUiUrls(parsedUi.host, parsedUi.port);
-      console.log(`Logs: ${existing.logPath}`);
-      this.printServiceControlHints();
+      await this.handleExistingManagedService({ existing, uiConfig, options });
       return;
     }
     if (existing) {
@@ -10258,109 +10801,72 @@ var ServiceCommands = class {
       console.error(portPreflight.message);
       return;
     }
-    const logPath = resolveServiceLogPath();
-    const logDir = resolve13(logPath, "..");
-    mkdirSync5(logDir, { recursive: true });
-    const logFd = openSync2(logPath, "a");
-    const readinessTimeoutMs = this.resolveStartupTimeoutMs(options.startupTimeoutMs);
-    const quickPhaseTimeoutMs = Math.min(8e3, readinessTimeoutMs);
-    const extendedPhaseTimeoutMs = Math.max(0, readinessTimeoutMs - quickPhaseTimeoutMs);
-    this.appendStartupStage(
-      logPath,
-      `start requested: ui=${uiConfig.host}:${uiConfig.port}, readinessTimeoutMs=${readinessTimeoutMs}`
-    );
-    console.log(`Starting ${APP_NAME3} background service (readiness timeout ${Math.ceil(readinessTimeoutMs / 1e3)}s)...`);
-    const serveArgs = buildServeArgs({ uiPort: uiConfig.port });
-    this.appendStartupStage(logPath, `spawning background process: ${process.execPath} ${[...process.execArgv, ...serveArgs].join(" ")}`);
-    const child = spawn3(process.execPath, [...process.execArgv, ...serveArgs], {
-      env: process.env,
-      stdio: ["ignore", logFd, logFd],
-      detached: true
-    });
-    this.appendStartupStage(logPath, `spawned background process pid=${child.pid ?? "unknown"}`);
-    closeSync2(logFd);
-    if (!child.pid) {
-      this.appendStartupStage(logPath, "spawn failed: child pid missing");
-      console.error("Error: Failed to start background service.");
-      this.printStartupFailureDiagnostics({
-        uiUrl,
-        apiUrl,
-        healthUrl,
-        logPath,
-        lastProbeError: null
-      });
-      return;
-    }
-    writeInitialManagedServiceState({
+    const startup = spawnManagedService({
+      appName: APP_NAME3,
       config: config2,
-      readinessTimeoutMs,
-      snapshot: { pid: child.pid, uiUrl, apiUrl, uiHost: uiConfig.host, uiPort: uiConfig.port, logPath }
-    });
-    this.appendStartupStage(logPath, `health probe started: ${healthUrl} (phase=quick, timeoutMs=${quickPhaseTimeoutMs})`);
-    let readiness = await this.waitForBackgroundServiceReady({
-      pid: child.pid,
+      uiConfig,
+      uiUrl,
+      apiUrl,
       healthUrl,
-      timeoutMs: quickPhaseTimeoutMs
+      startupTimeoutMs: options.startupTimeoutMs,
+      resolveStartupTimeoutMs: this.resolveStartupTimeoutMs,
+      appendStartupStage: this.appendStartupStage,
+      printStartupFailureDiagnostics: this.printStartupFailureDiagnostics,
+      resolveServiceLogPath
     });
-    if (!readiness.ready && isProcessRunning(child.pid) && extendedPhaseTimeoutMs > 0) {
-      console.warn(
-        `Warning: Background service is still running but not ready after ${Math.ceil(quickPhaseTimeoutMs / 1e3)}s; waiting up to ${Math.ceil(extendedPhaseTimeoutMs / 1e3)}s more.`
-      );
-      this.appendStartupStage(
-        logPath,
-        `health probe entering extended phase (timeoutMs=${extendedPhaseTimeoutMs}, lastError=${readiness.lastProbeError ?? "none"})`
-      );
-      readiness = await this.waitForBackgroundServiceReady({
-        pid: child.pid,
-        healthUrl,
-        timeoutMs: extendedPhaseTimeoutMs
-      });
+    if (!startup) {
+      return;
     }
+    const readiness = await waitForManagedServiceReadiness({
+      appName: APP_NAME3,
+      childPid: startup.snapshot.pid,
+      healthUrl,
+      logPath: startup.logPath,
+      readinessTimeoutMs: startup.readinessTimeoutMs,
+      quickPhaseTimeoutMs: startup.quickPhaseTimeoutMs,
+      extendedPhaseTimeoutMs: startup.extendedPhaseTimeoutMs,
+      appendStartupStage: this.appendStartupStage,
+      waitForBackgroundServiceReady: this.waitForBackgroundServiceReady,
+      isProcessRunning
+    });
     if (!readiness.ready) {
-      if (!isProcessRunning(child.pid)) {
+      if (!isProcessRunning(startup.snapshot.pid)) {
         clearServiceState();
         const hint = readiness.lastProbeError ? ` Last probe error: ${readiness.lastProbeError}` : "";
-        this.appendStartupStage(logPath, `startup failed: process exited before ready.${hint}`);
-        console.error(`Error: Failed to start background service. Check logs: ${logPath}.${hint}`);
+        this.appendStartupStage(startup.logPath, `startup failed: process exited before ready.${hint}`);
+        console.error(`Error: Failed to start background service. Check logs: ${startup.logPath}.${hint}`);
         this.printStartupFailureDiagnostics({
           uiUrl,
           apiUrl,
           healthUrl,
-          logPath,
+          logPath: startup.logPath,
           lastProbeError: readiness.lastProbeError
         });
         return;
       }
-      this.appendStartupStage(
-        logPath,
-        `startup degraded: process alive but health probe timed out after ${readinessTimeoutMs}ms (lastError=${readiness.lastProbeError ?? "none"})`
-      );
     }
-    child.unref();
+    startup.child.unref();
     const state = writeReadyManagedServiceState({
-      readinessTimeoutMs,
+      readinessTimeoutMs: startup.readinessTimeoutMs,
       readiness,
-      snapshot: { pid: child.pid, uiUrl, apiUrl, uiHost: uiConfig.host, uiPort: uiConfig.port, logPath }
+      snapshot: startup.snapshot
+    });
+    await reportManagedServiceStart({
+      appName: APP_NAME3,
+      state,
+      uiConfig,
+      uiUrl,
+      apiUrl,
+      readinessTimeoutMs: startup.readinessTimeoutMs,
+      readiness,
+      printPublicUiUrls: this.printPublicUiUrls,
+      printServiceControlHints: this.printServiceControlHints
     });
-    if (!readiness.ready) {
-      const hint = readiness.lastProbeError ? ` Last probe error: ${readiness.lastProbeError}` : "";
-      console.warn(
-        `Warning: ${APP_NAME3} is running (PID ${state.pid}) but not healthy yet after ${Math.ceil(readinessTimeoutMs / 1e3)}s. Marked as degraded.${hint}`
-      );
-      console.warn(`Tip: Run "${APP_NAME3} status --json" and check logs: ${logPath}`);
-    } else {
-      console.log(`\u2713 ${APP_NAME3} started in background (PID ${state.pid})`);
-    }
-    console.log(`UI: ${uiUrl}`);
-    console.log(`API: ${apiUrl}`);
-    await this.printPublicUiUrls(uiConfig.host, uiConfig.port);
-    console.log(`Logs: ${logPath}`);
-    this.printServiceControlHints();
     if (options.open) {
       openBrowser(uiUrl);
     }
-  }
-  async stopService() {
+  };
+  stopService = async () => {
     const state = readServiceState();
     if (!state) {
       console.log("No running service found.");
@@ -10390,8 +10896,8 @@ var ServiceCommands = class {
     }
     clearServiceState();
     console.log(`\u2713 ${APP_NAME3} stopped`);
-  }
-  async waitForBackgroundServiceReady(params) {
+  };
+  waitForBackgroundServiceReady = async (params) => {
     const startedAt = Date.now();
     let lastProbeError = null;
     while (Date.now() - startedAt < params.timeoutMs) {
@@ -10401,18 +10907,18 @@ var ServiceCommands = class {
       const probe = await this.probeHealthEndpoint(params.healthUrl);
       if (!probe.healthy) {
         lastProbeError = probe.error;
-        await new Promise((resolve16) => setTimeout(resolve16, 200));
+        await new Promise((resolve17) => setTimeout(resolve17, 200));
         continue;
       }
-      await new Promise((resolve16) => setTimeout(resolve16, 300));
+      await new Promise((resolve17) => setTimeout(resolve17, 300));
       if (isProcessRunning(params.pid)) {
         return { ready: true, lastProbeError: null };
       }
-      await new Promise((resolve16) => setTimeout(resolve16, 200));
+      await new Promise((resolve17) => setTimeout(resolve17, 200));
     }
     return { ready: false, lastProbeError };
-  }
-  resolveStartupTimeoutMs(overrideTimeoutMs) {
+  };
+  resolveStartupTimeoutMs = (overrideTimeoutMs) => {
     const fallback = process.platform === "win32" ? 28e3 : 33e3;
     const envRaw = process.env.NEXTCLAW_START_TIMEOUT_MS?.trim();
     const envValue = envRaw ? Number(envRaw) : Number.NaN;
@@ -10420,8 +10926,8 @@ var ServiceCommands = class {
     const fromOverride = Number.isFinite(overrideTimeoutMs) && Number(overrideTimeoutMs) > 0 ? Math.floor(Number(overrideTimeoutMs)) : null;
     const resolved = fromOverride ?? fromEnv ?? fallback;
     return Math.max(3e3, resolved);
-  }
-  appendStartupStage(logPath, message) {
+  };
+  appendStartupStage = (logPath, message) => {
     try {
       appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] [startup] ${message}
 `, "utf-8");
@@ -10429,8 +10935,8 @@ var ServiceCommands = class {
       const detail = error instanceof Error ? error.message : String(error);
       console.error(`Warning: failed to write startup diagnostics log (${logPath}): ${detail}`);
     }
-  }
-  printStartupFailureDiagnostics(params) {
+  };
+  printStartupFailureDiagnostics = (params) => {
     const statePath = resolveServiceStatePath();
     const lines = [
       "Startup diagnostics:",
@@ -10444,8 +10950,8 @@ var ServiceCommands = class {
       lines.push(`- Last probe detail: ${params.lastProbeError}`);
     }
     console.error(lines.join("\n"));
-  }
-  async checkUiPortPreflight(params) {
+  };
+  checkUiPortPreflight = async (params) => {
     const availability = await this.checkPortAvailability({
       host: params.host,
       port: params.port
@@ -10477,27 +10983,27 @@ var ServiceCommands = class {
       ok: false,
       message: lines.join("\n")
     };
-  }
-  async checkPortAvailability(params) {
-    return await new Promise((resolve16) => {
+  };
+  checkPortAvailability = async (params) => {
+    return await new Promise((resolve17) => {
       const server = createNetServer2();
       server.once("error", (error) => {
-        resolve16({
+        resolve17({
           available: false,
           detail: `bind failed on ${params.host}:${params.port} (${String(error)})`
         });
       });
       server.listen(params.port, params.host, () => {
         server.close(() => {
-          resolve16({
+          resolve17({
             available: true,
             detail: `bind ok on ${params.host}:${params.port}`
           });
         });
       });
     });
-  }
-  getHeaderValue(headers, key) {
+  };
+  getHeaderValue = (headers, key) => {
     const value = headers[key];
     if (typeof value === "string") {
       const normalized = value.trim();
@@ -10508,16 +11014,16 @@ var ServiceCommands = class {
       return joined.length > 0 ? joined : null;
     }
     return null;
-  }
-  formatProbeBodySnippet(raw, maxLength = 180) {
+  };
+  formatProbeBodySnippet = (raw, maxLength = 180) => {
     const normalized = raw.replace(/\s+/g, " ").trim();
     if (!normalized) {
       return null;
     }
     const clipped = normalized.length > maxLength ? `${normalized.slice(0, maxLength)}...` : normalized;
     return JSON.stringify(clipped);
-  }
-  async probeHealthEndpoint(healthUrl) {
+  };
+  probeHealthEndpoint = async (healthUrl) => {
     let parsed;
     try {
       parsed = new URL(healthUrl);
@@ -10525,7 +11031,7 @@ var ServiceCommands = class {
       return { healthy: false, error: "invalid health URL" };
     }
     const requestImpl = parsed.protocol === "https:" ? httpsRequest : httpRequest;
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       const req = requestImpl(
         {
           protocol: parsed.protocol,
@@ -10561,19 +11067,19 @@ var ServiceCommands = class {
               if (bodySnippet) {
                 details.push(`body=${bodySnippet}`);
               }
-              resolve16({ healthy: false, error: details.join("; ") });
+              resolve17({ healthy: false, error: details.join("; ") });
               return;
             }
             try {
               const payload = JSON.parse(responseText);
               const healthy = payload?.ok === true && payload?.data?.status === "ok";
               if (!healthy) {
-                resolve16({ healthy: false, error: "health payload not ok" });
+                resolve17({ healthy: false, error: "health payload not ok" });
                 return;
               }
-              resolve16({ healthy: true, error: null });
+              resolve17({ healthy: true, error: null });
             } catch {
-              resolve16({ healthy: false, error: "invalid health JSON response" });
+              resolve17({ healthy: false, error: "invalid health JSON response" });
             }
           });
         }
@@ -10582,24 +11088,24 @@ var ServiceCommands = class {
         req.destroy(new Error("probe timeout"));
       });
       req.on("error", (error) => {
-        resolve16({ healthy: false, error: error.message || String(error) });
+        resolve17({ healthy: false, error: error.message || String(error) });
       });
       req.end();
     });
-  }
-  createMissingProvider(config2) {
+  };
+  createMissingProvider = (config2) => {
     return this.makeMissingProvider(config2);
-  }
-  createProvider(config2, options) {
+  };
+  createProvider = (config2, options) => {
     if (options?.allowMissing) {
       return this.makeProvider(config2, { allowMissing: true });
     }
     return this.makeProvider(config2);
-  }
-  makeMissingProvider(config2) {
+  };
+  makeMissingProvider = (config2) => {
     return new MissingProvider(config2.agents.defaults.model);
-  }
-  makeProvider(config2, options) {
+  };
+  makeProvider = (config2, options) => {
     const provider = getProvider(config2);
     const model = config2.agents.defaults.model;
     if (!provider?.apiKey && !model.startsWith("bedrock/")) {
@@ -10618,8 +11124,8 @@ var ServiceCommands = class {
       providerName: getProviderName(config2),
       wireApi: provider?.wireApi ?? null
     });
-  }
-  async printPublicUiUrls(host, port) {
+  };
+  printPublicUiUrls = async (host, port) => {
     if (isLoopbackHost(host)) {
       console.log("Public URL: disabled (UI host is loopback). Current release expects public exposure; run nextclaw restart.");
       return;
@@ -10641,42 +11147,28 @@ var ServiceCommands = class {
     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() {
+  };
+  printServiceControlHints = () => {
     console.log("Service controls:");
     console.log(`  - Check status: ${APP_NAME3} status`);
     console.log(`  - If you need to stop the service, run: ${APP_NAME3} stop`);
-  }
-  installBuiltinMarketplaceSkill(slug, force) {
-    const workspace = getWorkspacePath12(loadConfig20().agents.defaults.workspace);
-    const destination = join7(workspace, "skills", slug);
-    const destinationSkillFile = join7(destination, "SKILL.md");
-    if (existsSync11(destinationSkillFile) && !force) {
-      return {
-        message: `${slug} is already installed`
-      };
-    }
+  };
+  installBuiltinMarketplaceSkill = (slug, _force) => {
+    const workspace = getWorkspacePath13(loadConfig21().agents.defaults.workspace);
     const loader = createSkillsLoader(workspace);
     const builtin = (loader?.listSkills(false) ?? []).find((skill) => skill.name === slug && skill.source === "builtin");
     if (!builtin) {
-      if (existsSync11(destinationSkillFile)) {
-        return {
-          message: `${slug} is already installed`
-        };
-      }
       return null;
     }
-    mkdirSync5(join7(workspace, "skills"), { recursive: true });
-    cpSync2(dirname3(builtin.path), destination, { recursive: true, force: true });
     return {
-      message: `Installed skill: ${slug}`
+      message: `${slug} is already available (built-in)`
     };
-  }
-  mergeCommandOutput(stdout, stderr) {
+  };
+  mergeCommandOutput = (stdout, stderr) => {
     return `${stdout}
 ${stderr}`.trim();
-  }
-  runCliSubcommand(args, timeoutMs = 18e4) {
+  };
+  runCliSubcommand = (args, timeoutMs = 18e4) => {
     const cliEntry = resolveCliSubcommandEntry({
       argvEntry: process.argv[1],
       importMetaUrl: import.meta.url
@@ -10685,11 +11177,11 @@ ${stderr}`.trim();
       cwd: process.cwd(),
       timeoutMs
     }).then((result) => this.mergeCommandOutput(result.stdout, result.stderr));
-  }
-  runCommand(command, args, options = {}) {
+  };
+  runCommand = (command, args, options = {}) => {
     const timeoutMs = options.timeoutMs ?? 18e4;
     return new Promise((resolvePromise, rejectPromise) => {
-      const child = spawn3(command, args, {
+      const child = spawn4(command, args, {
         cwd: options.cwd ?? process.cwd(),
         env: process.env,
         stdio: ["ignore", "pipe", "pipe"]
@@ -10722,13 +11214,12 @@ ${stderr}`.trim();
         rejectPromise(new Error(output || `command failed with code ${code ?? 1}`));
       });
     });
-  }
+  };
 };
 
 // src/cli/workspace.ts
-import { cpSync as cpSync3, existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync9, readdirSync as readdirSync2, rmSync as rmSync6, writeFileSync as writeFileSync5 } from "fs";
-import { createRequire as createRequire2 } from "module";
-import { dirname as dirname4, join as join8, resolve as resolve14 } from "path";
+import { cpSync, existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync9, rmSync as rmSync6, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname3, join as join8, resolve as resolve15 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { APP_NAME as APP_NAME4, getDataDir as getDataDir10 } from "@nextclaw/core";
 import { spawnSync as spawnSync3 } from "child_process";
@@ -10750,7 +11241,6 @@ var WorkspaceManager = class {
       { source: "USER.md", target: "USER.md" },
       { source: "IDENTITY.md", target: "IDENTITY.md" },
       { source: "TOOLS.md", target: "TOOLS.md" },
-      { source: "USAGE.md", target: "USAGE.md" },
       { source: "BOOT.md", target: "BOOT.md" },
       { source: "BOOTSTRAP.md", target: "BOOTSTRAP.md" },
       { source: "HEARTBEAT.md", target: "HEARTBEAT.md" },
@@ -10759,93 +11249,42 @@ var WorkspaceManager = class {
     ];
     for (const entry of templateFiles) {
       const filePath = join8(workspace, entry.target);
-      if (!force && existsSync12(filePath)) {
+      if (!force && existsSync11(filePath)) {
         continue;
       }
       const templatePath = join8(templateDir, entry.source);
-      if (!existsSync12(templatePath)) {
+      if (!existsSync11(templatePath)) {
         console.warn(`Warning: Template file missing: ${templatePath}`);
         continue;
       }
       const raw = readFileSync9(templatePath, "utf-8");
       const content = raw.replace(/\$\{APP_NAME\}/g, APP_NAME4);
-      mkdirSync6(dirname4(filePath), { recursive: true });
+      mkdirSync6(dirname3(filePath), { recursive: true });
       writeFileSync5(filePath, content);
       created.push(entry.target);
     }
     const memoryDir = join8(workspace, "memory");
-    if (!existsSync12(memoryDir)) {
+    if (!existsSync11(memoryDir)) {
       mkdirSync6(memoryDir, { recursive: true });
       created.push(join8("memory", ""));
     }
     const skillsDir = join8(workspace, "skills");
-    if (!existsSync12(skillsDir)) {
+    if (!existsSync11(skillsDir)) {
       mkdirSync6(skillsDir, { recursive: true });
       created.push(join8("skills", ""));
     }
-    const seeded = this.seedBuiltinSkills(skillsDir, { force });
-    if (seeded > 0) {
-      created.push(`skills (seeded ${seeded} built-ins)`);
-    }
     return { created };
   }
-  seedBuiltinSkills(targetDir, options = {}) {
-    const sourceDir = this.resolveBuiltinSkillsDir();
-    if (!sourceDir) {
-      return 0;
-    }
-    const force = Boolean(options.force);
-    let seeded = 0;
-    for (const entry of readdirSync2(sourceDir, { withFileTypes: true })) {
-      if (!entry.isDirectory()) {
-        continue;
-      }
-      const src = join8(sourceDir, entry.name);
-      if (!existsSync12(join8(src, "SKILL.md"))) {
-        continue;
-      }
-      const dest = join8(targetDir, entry.name);
-      if (!force && existsSync12(dest)) {
-        continue;
-      }
-      try {
-        cpSync3(src, dest, { recursive: true, force: true });
-        seeded += 1;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.warn(`Warning: Failed to seed builtin skill '${entry.name}': ${message}`);
-      }
-    }
-    return seeded;
-  }
-  resolveBuiltinSkillsDir() {
-    try {
-      const require3 = createRequire2(import.meta.url);
-      const entry = require3.resolve("@nextclaw/core");
-      const pkgRoot = resolve14(dirname4(entry), "..");
-      const distSkills = join8(pkgRoot, "dist", "skills");
-      if (existsSync12(distSkills)) {
-        return distSkills;
-      }
-      const srcSkills = join8(pkgRoot, "src", "agent", "skills");
-      if (existsSync12(srcSkills)) {
-        return srcSkills;
-      }
-      return null;
-    } catch {
-      return null;
-    }
-  }
   resolveTemplateDir() {
     const override = process.env.NEXTCLAW_TEMPLATE_DIR?.trim();
     if (override) {
       return override;
     }
-    const cliDir = resolve14(fileURLToPath4(new URL(".", import.meta.url)));
-    const pkgRoot = resolve14(cliDir, "..", "..");
+    const cliDir = resolve15(fileURLToPath4(new URL(".", import.meta.url)));
+    const pkgRoot = resolve15(cliDir, "..", "..");
     const candidates = [join8(pkgRoot, "templates")];
     for (const candidate of candidates) {
-      if (existsSync12(candidate)) {
+      if (existsSync11(candidate)) {
         return candidate;
       }
     }
@@ -10853,21 +11292,21 @@ var WorkspaceManager = class {
   }
   getBridgeDir() {
     const userBridge = join8(getDataDir10(), "bridge");
-    if (existsSync12(join8(userBridge, "dist", "index.js"))) {
+    if (existsSync11(join8(userBridge, "dist", "index.js"))) {
       return userBridge;
     }
     if (!which("npm")) {
       console.error("npm not found. Please install Node.js >= 18.");
       process.exit(1);
     }
-    const cliDir = resolve14(fileURLToPath4(new URL(".", import.meta.url)));
-    const pkgRoot = resolve14(cliDir, "..", "..");
+    const cliDir = resolve15(fileURLToPath4(new URL(".", import.meta.url)));
+    const pkgRoot = resolve15(cliDir, "..", "..");
     const pkgBridge = join8(pkgRoot, "bridge");
     const srcBridge = join8(pkgRoot, "..", "..", "bridge");
     let source = null;
-    if (existsSync12(join8(pkgBridge, "package.json"))) {
+    if (existsSync11(join8(pkgBridge, "package.json"))) {
       source = pkgBridge;
-    } else if (existsSync12(join8(srcBridge, "package.json"))) {
+    } else if (existsSync11(join8(srcBridge, "package.json"))) {
       source = srcBridge;
     }
     if (!source) {
@@ -10875,11 +11314,11 @@ var WorkspaceManager = class {
       process.exit(1);
     }
     console.log(`${this.logo} Setting up bridge...`);
-    mkdirSync6(resolve14(userBridge, ".."), { recursive: true });
-    if (existsSync12(userBridge)) {
+    mkdirSync6(resolve15(userBridge, ".."), { recursive: true });
+    if (existsSync11(userBridge)) {
       rmSync6(userBridge, { recursive: true, force: true });
     }
-    cpSync3(source, userBridge, {
+    cpSync(source, userBridge, {
       recursive: true,
       filter: (src) => !src.includes("node_modules") && !src.includes("dist")
     });
@@ -10908,12 +11347,6 @@ var WorkspaceManager = class {
 var LOGO = "\u{1F916}";
 var EXIT_COMMANDS = /* @__PURE__ */ new Set(["exit", "quit", "/exit", "/quit", ":q"]);
 var FORCED_PUBLIC_UI_HOST2 = "0.0.0.0";
-function resolveSkillsInstallWorkdir(params) {
-  if (params.explicitWorkdir) {
-    return expandHome2(params.explicitWorkdir);
-  }
-  return getWorkspacePath13(params.configuredWorkspace);
-}
 var CliRuntime = class {
   logo;
   restartCoordinator;
@@ -10925,6 +11358,7 @@ var CliRuntime = class {
   mcpCommands;
   secretsCommands;
   pluginCommands;
+  agentCommands;
   channelCommands;
   cronCommands;
   platformAuthCommands;
@@ -10936,7 +11370,8 @@ var CliRuntime = class {
     this.logo = options.logo ?? LOGO;
     this.workspaceManager = measureStartupSync("cli.runtime.workspace_manager", () => new WorkspaceManager(this.logo));
     this.serviceCommands = measureStartupSync("cli.runtime.service_commands", () => new ServiceCommands({
-      requestRestart: (params) => this.requestRestart(params)
+      requestRestart: (params) => this.requestRestart(params),
+      initializeAgentHomeDirectory: (homeDirectory) => this.workspaceManager.createWorkspaceTemplates(homeDirectory)
     }));
     this.configCommands = measureStartupSync("cli.runtime.config_commands", () => new ConfigCommands({
       requestRestart: (params) => this.requestRestart(params)
@@ -10946,6 +11381,11 @@ var CliRuntime = class {
       requestRestart: (params) => this.requestRestart(params)
     }));
     this.pluginCommands = measureStartupSync("cli.runtime.plugin_commands", () => new PluginCommands());
+    this.agentCommands = measureStartupSync("cli.runtime.agent_commands", () => new AgentCommands({
+      requestRestart: (params) => this.requestRestart(params),
+      initializeAgentHomeDirectory: (homeDirectory) => this.workspaceManager.createWorkspaceTemplates(homeDirectory),
+      appName: APP_NAME5
+    }));
     this.channelCommands = measureStartupSync("cli.runtime.channel_commands", () => new ChannelCommands({
       logo: this.logo,
       getBridgeDir: () => this.workspaceManager.getBridgeDir(),
@@ -10974,13 +11414,13 @@ var CliRuntime = class {
   get version() {
     return getPackageVersion();
   }
-  scheduleProcessExit(delayMs, reason) {
+  scheduleProcessExit = (delayMs, reason) => {
     console.warn(`Gateway restart requested (${reason}).`);
     setTimeout(() => {
       process.exit(0);
     }, delayMs);
-  }
-  async restartBackgroundService(reason) {
+  };
+  restartBackgroundService = async (reason) => {
     if (this.serviceRestartTask) {
       return this.serviceRestartTask;
     }
@@ -11010,8 +11450,8 @@ var CliRuntime = class {
     } finally {
       this.serviceRestartTask = null;
     }
-  }
-  armManagedServiceRelaunch(params) {
+  };
+  armManagedServiceRelaunch = (params) => {
     const strategy = params.strategy ?? "background-service-or-manual";
     if (strategy !== "background-service-or-exit" && strategy !== "exit-process") {
       return;
@@ -11027,7 +11467,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() || fileURLToPath5(new URL("./index.js", import.meta.url));
     const startArgs = [cliPath, "start", "--ui-port", String(uiPort)];
-    const serviceStatePath = resolve15(getDataDir11(), "run", "service.json");
+    const serviceStatePath = resolve16(getDataDir11(), "run", "service.json");
     const helperScript = [
       'const { spawnSync } = require("node:child_process");',
       'const { readFileSync } = require("node:fs");',
@@ -11086,7 +11526,7 @@ var CliRuntime = class {
       "}, delayMs);"
     ].join("\n");
     try {
-      const helper = spawn4(process.execPath, ["-e", helperScript], {
+      const helper = spawn5(process.execPath, ["-e", helperScript], {
         detached: true,
         stdio: "ignore",
         env: process.env
@@ -11097,8 +11537,8 @@ var CliRuntime = class {
     } catch (error) {
       console.error(`Failed to arm gateway self-restart: ${String(error)}`);
     }
-  }
-  async requestRestart(params) {
+  };
+  requestRestart = async (params) => {
     this.armManagedServiceRelaunch({
       reason: params.reason,
       strategy: params.strategy,
@@ -11121,8 +11561,8 @@ var CliRuntime = class {
       return;
     }
     console.warn(result.message);
-  }
-  async writeRestartSentinelFromExecContext(reason) {
+  };
+  writeRestartSentinelFromExecContext = async (reason) => {
     const sessionKeyRaw = process.env.NEXTCLAW_RUNTIME_SESSION_KEY;
     const sessionKey = typeof sessionKeyRaw === "string" ? sessionKeyRaw.trim() : "";
     if (!sessionKey) {
@@ -11144,23 +11584,23 @@ var CliRuntime = class {
         `Warning: failed to write restart sentinel from exec context: ${String(error)}`
       );
     }
-  }
-  async onboard() {
+  };
+  onboard = async () => {
     console.warn(
       `Warning: ${APP_NAME5} onboard is deprecated. Use "${APP_NAME5} init" instead.`
     );
     await this.init({ source: "onboard" });
-  }
-  async init(options = {}) {
+  };
+  init = async (options = {}) => {
     const source = options.source ?? "init";
     const prefix = options.auto ? "Auto init" : "Init";
     const force = Boolean(options.force);
     const configPath = getConfigPath11();
     const createdConfig = initializeConfigIfMissing(configPath);
-    const config2 = loadConfig21();
+    const config2 = loadConfig22();
     const workspaceSetting = config2.agents.defaults.workspace;
-    const workspacePath = !workspaceSetting || workspaceSetting === DEFAULT_WORKSPACE_PATH ? join9(getDataDir11(), DEFAULT_WORKSPACE_DIR) : expandHome2(workspaceSetting);
-    const workspaceExisted = existsSync13(workspacePath);
+    const workspacePath = !workspaceSetting || workspaceSetting === DEFAULT_WORKSPACE_PATH ? join9(getDataDir11(), DEFAULT_WORKSPACE_DIR) : expandHome3(workspaceSetting);
+    const workspaceExisted = existsSync12(workspacePath);
     mkdirSync7(workspacePath, { recursive: true });
     const templateResult = this.workspaceManager.createWorkspaceTemplates(
       workspacePath,
@@ -11189,12 +11629,12 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
         `Tip: Run "${APP_NAME5} init${force ? " --force" : ""}" to re-run initialization if needed.`
       );
     }
-  }
-  async login(opts = {}) {
+  };
+  login = async (opts = {}) => {
     await this.init({ source: "login", auto: true });
     await this.platformAuthCommands.login(opts);
-  }
-  async gateway(opts) {
+  };
+  gateway = async (opts) => {
     const uiOverrides = {
       host: FORCED_PUBLIC_UI_HOST2
     };
@@ -11208,8 +11648,8 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
       uiOverrides.open = true;
     }
     await this.serviceCommands.startGateway({ uiOverrides });
-  }
-  async ui(opts) {
+  };
+  ui = async (opts) => {
     const uiOverrides = {
       enabled: true,
       host: FORCED_PUBLIC_UI_HOST2,
@@ -11222,9 +11662,9 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
       uiOverrides,
       allowMissingProvider: true
     });
-  }
-  async start(opts) {
-    const startupTimeoutMs = this.parseStartTimeoutMs(opts.startTimeout);
+  };
+  start = async (opts) => {
+    const startupTimeoutMs = parseStartTimeoutMs(opts.startTimeout);
     await this.init({ source: "start", auto: true });
     const uiOverrides = {
       enabled: true,
@@ -11239,8 +11679,8 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
       open: Boolean(opts.open),
       startupTimeoutMs
     });
-  }
-  async restart(opts) {
+  };
+  restart = async (opts) => {
     await this.writeRestartSentinelFromExecContext("cli.restart");
     const state = readServiceState();
     if (state && isProcessRunning(state.pid)) {
@@ -11253,8 +11693,8 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
       console.log("No running service found. Starting a new service.");
     }
     await this.start(opts);
-  }
-  async serve(opts) {
+  };
+  serve = async (opts) => {
     const uiOverrides = {
       enabled: true,
       host: FORCED_PUBLIC_UI_HOST2,
@@ -11267,32 +11707,21 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
       uiOverrides,
       open: Boolean(opts.open)
     });
-  }
-  parseStartTimeoutMs(value) {
-    if (value === void 0) {
-      return void 0;
-    }
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-      console.error("Invalid --start-timeout value. Provide milliseconds (e.g. 45000).");
-      process.exit(1);
-    }
-    return Math.floor(parsed);
-  }
-  async stop() {
+  };
+  stop = async () => {
     await this.serviceCommands.stopService();
-  }
-  async agent(opts) {
+  };
+  agent = async (opts) => {
     const configPath = getConfigPath11();
-    const config2 = resolveConfigSecrets7(loadConfig21(), { configPath });
-    const workspace = getWorkspacePath13(config2.agents.defaults.workspace);
+    const config2 = resolveConfigSecrets7(loadConfig22(), { configPath });
+    const workspace = getWorkspacePath14(config2.agents.defaults.workspace);
     const pluginRegistry = loadPluginRegistry(config2, workspace);
     const extensionRegistry = toExtensionRegistry(pluginRegistry);
     logPluginDiagnostics(pluginRegistry);
     const pluginChannelBindings = getPluginChannelBindings6(pluginRegistry);
     setPluginRuntimeBridge3({
       loadConfig: () => toPluginConfigView(
-        resolveConfigSecrets7(loadConfig21(), { configPath }),
+        resolveConfigSecrets7(loadConfig22(), { configPath }),
         pluginChannelBindings
       ),
       writeConfigFile: async (nextConfigView) => {
@@ -11301,7 +11730,7 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
             "plugin runtime writeConfigFile expects an object config"
           );
         }
-        const current = loadConfig21();
+        const current = loadConfig22();
         const next = mergePluginConfigView(
           current,
           nextConfigView,
@@ -11333,7 +11762,7 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
         resolveMessageToolHints: ({ channel, accountId }) => resolvePluginChannelMessageToolHints3({
           registry: pluginRegistry,
           channel,
-          cfg: resolveConfigSecrets7(loadConfig21(), { configPath }),
+          cfg: resolveConfigSecrets7(loadConfig22(), { configPath }),
           accountId
         })
       });
@@ -11353,9 +11782,9 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
 `
       );
       const historyFile = join9(getDataDir11(), "history", "cli_history");
-      const historyDir = resolve15(historyFile, "..");
+      const historyDir = resolve16(historyFile, "..");
       mkdirSync7(historyDir, { recursive: true });
-      const history = existsSync13(historyFile) ? readFileSync10(historyFile, "utf-8").split("\n").filter(Boolean) : [];
+      const history = existsSync12(historyFile) ? readFileSync10(historyFile, "utf-8").split("\n").filter(Boolean) : [];
       const rl = createInterface3({
         input: process.stdin,
         output: process.stdout
@@ -11389,8 +11818,8 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
     } finally {
       setPluginRuntimeBridge3(null);
     }
-  }
-  async update(opts) {
+  };
+  update = async (opts) => {
     let timeoutMs;
     if (opts.timeout !== void 0) {
       const parsed = Number(opts.timeout);
@@ -11436,76 +11865,88 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
     if (state && isProcessRunning(state.pid)) {
       console.log(`Tip: restart ${APP_NAME5} to apply the update.`);
     }
-  }
-  pluginsList(opts = {}) {
+  };
+  agentsList = (opts = {}) => {
+    this.agentCommands.agentsList(opts);
+  };
+  agentsNew = async (agentId, opts = {}) => {
+    await this.agentCommands.agentsNew(agentId, opts);
+  };
+  agentsUpdate = async (agentId, opts = {}) => {
+    await this.agentCommands.agentsUpdate(agentId, opts);
+  };
+  agentsRemove = async (agentId, opts = {}) => {
+    await this.agentCommands.agentsRemove(agentId, opts);
+  };
+  pluginsList = (opts = {}) => {
     this.pluginCommands.pluginsList(opts);
-  }
-  pluginsInfo(id, opts = {}) {
+  };
+  pluginsInfo = (id, opts = {}) => {
     this.pluginCommands.pluginsInfo(id, opts);
-  }
-  async pluginsEnable(id) {
+  };
+  pluginsEnable = async (id) => {
     await this.pluginCommands.pluginsEnable(id);
-  }
-  async pluginsDisable(id) {
+  };
+  pluginsDisable = async (id) => {
     await this.pluginCommands.pluginsDisable(id);
-  }
-  async pluginsUninstall(id, opts = {}) {
+  };
+  pluginsUninstall = async (id, opts = {}) => {
     await this.pluginCommands.pluginsUninstall(id, opts);
-  }
-  async pluginsInstall(pathOrSpec, opts = {}) {
+  };
+  pluginsInstall = async (pathOrSpec, opts = {}) => {
     await this.pluginCommands.pluginsInstall(pathOrSpec, opts);
-  }
-  pluginsDoctor() {
+  };
+  pluginsDoctor = () => {
     this.pluginCommands.pluginsDoctor();
-  }
-  configGet(pathExpr, opts = {}) {
+  };
+  configGet = (pathExpr, opts = {}) => {
     this.configCommands.configGet(pathExpr, opts);
-  }
-  async configSet(pathExpr, value, opts = {}) {
+  };
+  configSet = async (pathExpr, value, opts = {}) => {
     await this.configCommands.configSet(pathExpr, value, opts);
-  }
-  async configUnset(pathExpr) {
+  };
+  configUnset = async (pathExpr) => {
     await this.configCommands.configUnset(pathExpr);
-  }
-  mcpList(opts = {}) {
+  };
+  mcpList = (opts = {}) => {
     this.mcpCommands.mcpList(opts);
-  }
-  async mcpAdd(name, command, opts = {}) {
+  };
+  mcpAdd = async (name, command, opts = {}) => {
     await this.mcpCommands.mcpAdd(name, command, opts);
-  }
-  async mcpRemove(name) {
+  };
+  mcpRemove = async (name) => {
     await this.mcpCommands.mcpRemove(name);
-  }
-  async mcpEnable(name) {
+  };
+  mcpEnable = async (name) => {
     await this.mcpCommands.mcpEnable(name);
-  }
-  async mcpDisable(name) {
+  };
+  mcpDisable = async (name) => {
     await this.mcpCommands.mcpDisable(name);
-  }
-  async mcpDoctor(name, opts = {}) {
+  };
+  mcpDoctor = async (name, opts = {}) => {
     await this.mcpCommands.mcpDoctor(name, opts);
-  }
-  secretsAudit(opts = {}) {
+  };
+  secretsAudit = (opts = {}) => {
     this.secretsCommands.secretsAudit(opts);
-  }
-  async secretsConfigure(opts) {
+  };
+  secretsConfigure = async (opts) => {
     await this.secretsCommands.secretsConfigure(opts);
-  }
-  async secretsApply(opts) {
+  };
+  secretsApply = async (opts) => {
     await this.secretsCommands.secretsApply(opts);
-  }
-  async secretsReload(opts = {}) {
+  };
+  secretsReload = async (opts = {}) => {
     await this.secretsCommands.secretsReload(opts);
-  }
-  channelsStatus() {
+  };
+  channelsStatus = () => {
     this.channelCommands.channelsStatus();
-  }
-  async channelsLogin(opts) {
+  };
+  channelsLogin = async (opts) => {
     await this.channelCommands.channelsLogin(opts);
-  }
-  async channelsAdd(opts) {
+  };
+  channelsAdd = async (opts) => {
     await this.channelCommands.channelsAdd(opts);
-  }
+  };
   cronList = async (opts) => {
     await this.cronCommands.cronList(opts);
   };
@@ -11521,14 +11962,14 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
   cronRun = async (jobId, opts) => {
     await this.cronCommands.cronRun(jobId, opts);
   };
-  async status(opts = {}) {
+  status = async (opts = {}) => {
     await this.diagnosticsCommands.status(opts);
-  }
-  async doctor(opts = {}) {
+  };
+  doctor = async (opts = {}) => {
     await this.diagnosticsCommands.doctor(opts);
-  }
-  async skillsInstall(options) {
-    const config2 = loadConfig21();
+  };
+  skillsInstall = async (options) => {
+    const config2 = loadConfig22();
     const workdir = resolveSkillsInstallWorkdir({
       explicitWorkdir: options.workdir,
       configuredWorkspace: config2.agents.defaults.workspace
@@ -11546,11 +11987,11 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
       console.log(`\u2713 Installed ${result.slug} (${result.source})`);
     }
     console.log(`  Path: ${result.destinationDir}`);
-  }
-  async skillsPublish(options) {
+  };
+  skillsPublish = async (options) => {
     const result = await publishMarketplaceSkill({
-      skillDir: expandHome2(options.dir),
-      metaFile: options.meta ? expandHome2(options.meta) : void 0,
+      skillDir: expandHome3(options.dir),
+      metaFile: options.meta ? expandHome3(options.meta) : void 0,
       slug: options.slug,
       name: options.name,
       summary: options.summary,
@@ -11566,11 +12007,11 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
     });
     console.log(`${result.created ? `\u2713 Published new skill: ${result.slug}` : `\u2713 Updated skill: ${result.slug}`}
   Files: ${result.fileCount}`);
-  }
-  async skillsUpdate(options) {
+  };
+  skillsUpdate = async (options) => {
     const result = await publishMarketplaceSkill({
-      skillDir: expandHome2(options.dir),
-      metaFile: options.meta ? expandHome2(options.meta) : void 0,
+      skillDir: expandHome3(options.dir),
+      metaFile: options.meta ? expandHome3(options.meta) : void 0,
       slug: options.slug,
       name: options.name,
       summary: options.summary,
@@ -11586,9 +12027,18 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
     });
     console.log(`\u2713 Updated skill: ${result.slug}`);
     console.log(`  Files: ${result.fileCount}`);
-  }
+  };
 };
 
+// src/cli/register-agents-commands.ts
+function registerAgentsCommands(program2, runtime2) {
+  const agents = program2.command("agents").description("Manage agents");
+  agents.command("list").description("List available agents").option("--json", "Output JSON", false).action((opts) => runtime2.agentsList(opts));
+  agents.command("new <agentId>").description("Create a new agent").option("--name <name>", "Agent display name").option("--description <description>", "Agent description").option("--avatar <avatar>", "Remote avatar URL or local image path").option("--home <path>", "Agent home directory").option("--json", "Output JSON", false).action(async (agentId, opts) => runtime2.agentsNew(agentId, opts));
+  agents.command("update <agentId>").description("Update an existing agent").option("--name <name>", "Agent display name").option("--description <description>", "Agent description").option("--avatar <avatar>", "Remote avatar URL or local image path").option("--json", "Output JSON", false).action(async (agentId, opts) => runtime2.agentsUpdate(agentId, opts));
+  agents.command("remove <agentId>").description("Remove an agent").option("--json", "Output JSON", false).action(async (agentId, opts) => runtime2.agentsRemove(agentId, opts));
+}
+
 // src/cli/index.ts
 logStartupTrace("cli.index.module_loaded");
 var program = new Command();
@@ -11611,6 +12061,7 @@ skills.command("install <slug>").description("Install a skill from NextClaw mark
 var withRepeatableTag = (value, previous = []) => [...previous, value];
 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 }));
+registerAgentsCommands(program, runtime);
 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));
@@ -11646,7 +12097,7 @@ channels.command("status").description("Show channel status").action(() => runti
 channels.command("login").description("Link device via QR code").option("--channel <id>", "Plugin channel id").option("--account <id>", "Channel account id").option("--url <url>", "Channel API base URL").option("--http-url <url>", "Alias for --url").option("-v, --verbose", "Verbose output", false).action(async (opts) => runtime.channelsLogin(opts));
 var cron = program.command("cron").description("Manage scheduled tasks");
 cron.command("list").option("--enabled-only", "Show only enabled jobs", false).option("-a, --all", "Deprecated: list all jobs (default behavior)", false).action(async (opts) => runtime.cronList({ enabledOnly: Boolean(opts.enabledOnly) }));
-cron.command("add").requiredOption("-n, --name <name>", "Job name").requiredOption("-m, --message <message>", "Message for agent").option("-e, --every <seconds>", "Run every N seconds").option("-c, --cron <expr>", "Cron expression").option("--at <iso>", "Run once at time (ISO format)").option("-d, --deliver", "Deliver response to channel").option("--to <recipient>", "Recipient for delivery").option("--channel <channel>", "Channel for delivery").option("--account <id>", "Account id for channel delivery").action(async (opts) => runtime.cronAdd(opts));
+cron.command("add").requiredOption("-n, --name <name>", "Job name").requiredOption("-m, --message <message>", "Message for agent").option("--agent <id>", "Target agent id").option("-e, --every <seconds>", "Run every N seconds").option("-c, --cron <expr>", "Cron expression").option("--at <iso>", "Run once at time (ISO format)").option("-d, --deliver", "Deliver response to channel").option("--to <recipient>", "Recipient for delivery").option("--channel <channel>", "Channel for delivery").option("--account <id>", "Account id for channel delivery").action(async (opts) => runtime.cronAdd(opts));
 cron.command("remove <jobId>").action(async (jobId) => runtime.cronRemove(jobId));
 cron.command("enable <jobId>").option("--disable", "Disable instead of enable").action(async (jobId, opts) => runtime.cronEnable(jobId, opts));
 cron.command("disable <jobId>").action(async (jobId) => runtime.cronEnable(jobId, { disable: true }));