nextclaw 0.16.0 → 0.16.2

package/dist/cli/index.js

@@ -10,7 +10,7 @@ import {
   loadConfig as loadConfig19,
   saveConfig as saveConfig11,
   getConfigPath as getConfigPath11,
-  getDataDir as getDataDir11,
+  getDataDir as getDataDir10,
   getWorkspacePath as getWorkspacePath12,
   expandHome as expandHome2,
   MessageBus as MessageBus3,
@@ -27,8 +27,8 @@ import {
   resolvePluginChannelMessageToolHints as resolvePluginChannelMessageToolHints3,
   setPluginRuntimeBridge as setPluginRuntimeBridge3
 } from "@nextclaw/openclaw-compat";
-import { existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
-import { join as join10, resolve as resolve14 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
+import { join as join9, resolve as resolve14 } from "path";
 import { createInterface as createInterface3 } from "readline";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { spawn as spawn4 } from "child_process";
@@ -75,9 +75,9 @@ var RestartCoordinator = class {
           message: "Restart already scheduled; skipping duplicate request."
         };
       }
-      const delay = typeof request.delayMs === "number" && Number.isFinite(request.delayMs) ? Math.max(0, Math.floor(request.delayMs)) : 100;
+      const delay2 = typeof request.delayMs === "number" && Number.isFinite(request.delayMs) ? Math.max(0, Math.floor(request.delayMs)) : 100;
       this.exitScheduled = true;
-      this.deps.scheduleProcessExit(delay, reason);
+      this.deps.scheduleProcessExit(delay2, reason);
       return {
         status: "exit-scheduled",
         message: `Restart scheduled (${reason}).`
@@ -197,6 +197,46 @@ function parseSessionKey(sessionKey) {
   };
 }
 
+// src/cli/startup-trace.ts
+var STARTUP_TRACE_ENABLED = process.env.NEXTCLAW_STARTUP_TRACE === "1";
+var STARTUP_TRACE_ORIGIN_MS = Date.now();
+function formatFields(fields) {
+  if (!fields) {
+    return "";
+  }
+  const parts = Object.entries(fields).filter(([, value]) => value !== void 0).map(([key, value]) => `${key}=${String(value)}`);
+  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+}
+function logStartupTrace(step, fields) {
+  if (!STARTUP_TRACE_ENABLED) {
+    return;
+  }
+  const elapsedMs = Date.now() - STARTUP_TRACE_ORIGIN_MS;
+  console.log(`[startup-trace] +${elapsedMs}ms ${step}${formatFields(fields)}`);
+}
+function measureStartupSync(step, fn, fields) {
+  const startedAt = Date.now();
+  try {
+    return fn();
+  } finally {
+    logStartupTrace(step, {
+      ...fields,
+      duration_ms: Date.now() - startedAt
+    });
+  }
+}
+async function measureStartupAsync(step, fn, fields) {
+  const startedAt = Date.now();
+  try {
+    return await fn();
+  } finally {
+    logStartupTrace(step, {
+      ...fields,
+      duration_ms: Date.now() - startedAt
+    });
+  }
+}
+
 // 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 { basename, dirname, isAbsolute, join, relative, resolve as resolve3 } from "path";
@@ -3953,12 +3993,13 @@ import {
   startPluginChannelGateways as startPluginChannelGateways2,
   stopPluginChannelGateways as stopPluginChannelGateways2
 } from "@nextclaw/openclaw-compat";
-import { appendFileSync, closeSync as closeSync2, cpSync as cpSync2, existsSync as existsSync12, mkdirSync as mkdirSync6, openSync as openSync2 } from "fs";
-import { dirname as dirname3, join as join8, resolve as resolve12 } from "path";
+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 resolve12 } from "path";
 import { spawn as spawn3 } from "child_process";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
 import { createServer as createNetServer2 } from "net";
+import { setImmediate as waitForNextTick } from "timers/promises";
 import chokidar from "chokidar";
 
 // src/cli/missing-provider.ts
@@ -6893,11 +6934,11 @@ var GatewayControllerImpl = class {
       await this.deps.requestRestart(options);
       return;
     }
-    const delay = typeof options?.delayMs === "number" && Number.isFinite(options.delayMs) ? Math.max(0, options.delayMs) : 100;
+    const delay2 = typeof options?.delayMs === "number" && Number.isFinite(options.delayMs) ? Math.max(0, options.delayMs) : 100;
     console.log(`Gateway restart requested via tool${options?.reason ? ` (${options.reason})` : ""}.`);
     setTimeout(() => {
       process.exit(0);
-    }, delay);
+    }, delay2);
   }
   status() {
     return {
@@ -7776,30 +7817,67 @@ var {
   saveConfig: saveConfig10,
   SessionManager
 } = NextclawCore;
+function createGatewayShellContext(params) {
+  const runtimeConfigPath = getConfigPath9();
+  const config2 = resolveConfigSecrets3(loadConfig17(), { configPath: runtimeConfigPath });
+  const workspace = getWorkspacePath10(config2.agents.defaults.workspace);
+  const cronStorePath = join6(getDataDir8(), "cron", "jobs.json");
+  const cron2 = new CronService2(cronStorePath);
+  const uiConfig = resolveUiConfig(config2, params.uiOverrides);
+  const uiStaticDir = params.uiStaticDir === void 0 ? resolveUiStaticDir() : params.uiStaticDir;
+  const remoteModule = createManagedRemoteModuleForUi({
+    loadConfig: () => resolveConfigSecrets3(loadConfig17(), { configPath: runtimeConfigPath }),
+    uiConfig
+  });
+  return {
+    runtimeConfigPath,
+    config: config2,
+    workspace,
+    cron: cron2,
+    uiConfig,
+    uiStaticDir,
+    remoteModule
+  };
+}
 function createGatewayStartupContext(params) {
   const state = {};
-  state.runtimeConfigPath = getConfigPath9();
-  state.config = resolveConfigSecrets3(loadConfig17(), { configPath: state.runtimeConfigPath });
-  state.workspace = getWorkspacePath10(state.config.agents.defaults.workspace);
-  state.pluginRegistry = loadPluginRegistry(state.config, state.workspace);
-  state.pluginChannelBindings = getPluginChannelBindings4(state.pluginRegistry);
-  state.extensionRegistry = toExtensionRegistry(state.pluginRegistry);
+  const shellContext = params.shellContext ?? createGatewayShellContext({
+    uiOverrides: params.uiOverrides,
+    uiStaticDir: params.uiStaticDir
+  });
+  state.runtimeConfigPath = shellContext.runtimeConfigPath;
+  state.config = shellContext.config;
+  state.workspace = shellContext.workspace;
+  state.cron = shellContext.cron;
+  state.uiConfig = shellContext.uiConfig;
+  state.uiStaticDir = shellContext.uiStaticDir;
+  state.remoteModule = shellContext.remoteModule;
+  state.pluginRegistry = measureStartupSync(
+    "service.gateway_context.load_plugin_registry",
+    () => loadPluginRegistry(state.config, state.workspace)
+  );
+  state.pluginChannelBindings = measureStartupSync(
+    "service.gateway_context.get_plugin_channel_bindings",
+    () => getPluginChannelBindings4(state.pluginRegistry)
+  );
+  state.extensionRegistry = measureStartupSync(
+    "service.gateway_context.to_extension_registry",
+    () => toExtensionRegistry(state.pluginRegistry)
+  );
   logPluginDiagnostics(state.pluginRegistry);
   state.bus = new MessageBus();
   const provider = params.allowMissingProvider === true ? params.makeProvider(state.config, { allowMissing: true }) : params.makeProvider(state.config);
-  state.providerManager = new ProviderManager({
-    defaultProvider: provider ?? params.makeMissingProvider(state.config),
-    config: state.config
-  });
-  state.sessionManager = new SessionManager(state.workspace);
-  const cronStorePath = join6(getDataDir8(), "cron", "jobs.json");
-  state.cron = new CronService2(cronStorePath);
-  state.uiConfig = resolveUiConfig(state.config, params.uiOverrides);
-  state.uiStaticDir = params.uiStaticDir === void 0 ? resolveUiStaticDir() : params.uiStaticDir;
-  state.remoteModule = createManagedRemoteModuleForUi({
-    loadConfig: () => resolveConfigSecrets3(loadConfig17(), { configPath: state.runtimeConfigPath }),
-    uiConfig: state.uiConfig
-  });
+  state.providerManager = measureStartupSync(
+    "service.gateway_context.provider_manager",
+    () => new ProviderManager({
+      defaultProvider: provider ?? params.makeMissingProvider(state.config),
+      config: state.config
+    })
+  );
+  state.sessionManager = measureStartupSync(
+    "service.gateway_context.session_manager",
+    () => new SessionManager(state.workspace)
+  );
   if (!provider) {
     console.warn(
       "Warning: No API key configured. The gateway is running, but agent replies are disabled until provider config is set."
@@ -7811,62 +7889,71 @@ function createGatewayStartupContext(params) {
     state.sessionManager,
     state.extensionRegistry.channels
   );
-  state.reloader = new ConfigReloader({
-    initialConfig: state.config,
-    channels: channels2,
-    bus: state.bus,
-    sessionManager: state.sessionManager,
-    providerManager: state.providerManager,
-    makeProvider: (nextConfig) => params.makeProvider(nextConfig, { allowMissing: true }) ?? params.makeMissingProvider(nextConfig),
-    loadConfig: () => resolveConfigSecrets3(loadConfig17(), { configPath: state.runtimeConfigPath }),
-    resolveChannelConfig: (nextConfig) => resolveChannelConfigView(nextConfig, state.pluginChannelBindings),
-    getExtensionChannels: () => state.extensionRegistry.channels,
-    onRestartRequired: (paths) => {
-      void params.requestRestart({
-        reason: `config reload requires restart: ${paths.join(", ")}`,
-        manualMessage: `Config changes require restart: ${paths.join(", ")}`,
-        strategy: "background-service-or-manual"
-      });
-    }
-  });
+  state.reloader = measureStartupSync(
+    "service.gateway_context.config_reloader",
+    () => new ConfigReloader({
+      initialConfig: state.config,
+      channels: channels2,
+      bus: state.bus,
+      sessionManager: state.sessionManager,
+      providerManager: state.providerManager,
+      makeProvider: (nextConfig) => params.makeProvider(nextConfig, { allowMissing: true }) ?? params.makeMissingProvider(nextConfig),
+      loadConfig: () => resolveConfigSecrets3(loadConfig17(), { configPath: state.runtimeConfigPath }),
+      resolveChannelConfig: (nextConfig) => resolveChannelConfigView(nextConfig, state.pluginChannelBindings),
+      getExtensionChannels: () => state.extensionRegistry.channels,
+      onRestartRequired: (paths) => {
+        void params.requestRestart({
+          reason: `config reload requires restart: ${paths.join(", ")}`,
+          manualMessage: `Config changes require restart: ${paths.join(", ")}`,
+          strategy: "background-service-or-manual"
+        });
+      }
+    })
+  );
   state.applyLiveConfigReload = async () => {
     await state.reloader.applyReloadPlan(resolveConfigSecrets3(loadConfig17(), { configPath: state.runtimeConfigPath }));
   };
-  state.gatewayController = new GatewayControllerImpl({
-    reloader: state.reloader,
-    cron: state.cron,
-    sessionManager: state.sessionManager,
-    getConfigPath: getConfigPath9,
-    saveConfig: saveConfig10,
-    requestRestart: async (options) => {
-      await params.requestRestart({
-        reason: options?.reason ?? "gateway tool restart",
-        manualMessage: "Restart the gateway to apply changes.",
-        strategy: "background-service-or-exit",
-        delayMs: options?.delayMs,
-        silentOnServiceRestart: true
-      });
-    }
-  });
-  state.runtimePool = new GatewayAgentRuntimePool({
-    bus: state.bus,
-    providerManager: state.providerManager,
-    sessionManager: state.sessionManager,
-    config: state.config,
-    cronService: state.cron,
-    restrictToWorkspace: state.config.tools.restrictToWorkspace,
-    searchConfig: state.config.search,
-    execConfig: state.config.tools.exec,
-    contextConfig: state.config.agents.context,
-    gatewayController: state.gatewayController,
-    extensionRegistry: state.extensionRegistry,
-    resolveMessageToolHints: ({ channel, accountId }) => resolvePluginChannelMessageToolHints({
-      registry: state.pluginRegistry,
-      channel,
-      cfg: resolveConfigSecrets3(loadConfig17(), { configPath: state.runtimeConfigPath }),
-      accountId
+  state.gatewayController = measureStartupSync(
+    "service.gateway_context.gateway_controller",
+    () => new GatewayControllerImpl({
+      reloader: state.reloader,
+      cron: state.cron,
+      sessionManager: state.sessionManager,
+      getConfigPath: getConfigPath9,
+      saveConfig: saveConfig10,
+      requestRestart: async (options) => {
+        await params.requestRestart({
+          reason: options?.reason ?? "gateway tool restart",
+          manualMessage: "Restart the gateway to apply changes.",
+          strategy: "background-service-or-exit",
+          delayMs: options?.delayMs,
+          silentOnServiceRestart: true
+        });
+      }
     })
-  });
+  );
+  state.runtimePool = measureStartupSync(
+    "service.gateway_context.runtime_pool",
+    () => new GatewayAgentRuntimePool({
+      bus: state.bus,
+      providerManager: state.providerManager,
+      sessionManager: state.sessionManager,
+      config: state.config,
+      cronService: state.cron,
+      restrictToWorkspace: state.config.tools.restrictToWorkspace,
+      searchConfig: state.config.search,
+      execConfig: state.config.tools.exec,
+      contextConfig: state.config.agents.context,
+      gatewayController: state.gatewayController,
+      extensionRegistry: state.extensionRegistry,
+      resolveMessageToolHints: ({ channel, accountId }) => resolvePluginChannelMessageToolHints({
+        registry: state.pluginRegistry,
+        channel,
+        cfg: resolveConfigSecrets3(loadConfig17(), { configPath: state.runtimeConfigPath }),
+        accountId
+      })
+    })
+  );
   state.cron.onJob = createCronJobHandler({ runtimePool: state.runtimePool, bus: state.bus });
   state.heartbeat = new HeartbeatService(
     state.workspace,
@@ -7978,755 +8065,13 @@ function createDeferredUiNcpAgent(basePath = DEFAULT_BASE_PATH) {
   };
 }
 
-// src/cli/commands/service-ui-chat-runtime.ts
-import { parseAgentScopedSessionKey as parseAgentScopedSessionKey2 } from "@nextclaw/core";
-function createServiceUiChatRuntime(params) {
-  return {
-    listSessionTypes: async () => {
-      const options = params.runtimePool.listAvailableEngineKinds().map((value) => ({
-        value,
-        label: resolveUiSessionTypeLabel(value)
-      }));
-      return {
-        defaultType: "native",
-        options
-      };
-    },
-    getCapabilities: async (request) => {
-      const sessionKey = typeof request.sessionKey === "string" && request.sessionKey.trim().length > 0 ? request.sessionKey.trim() : `ui:capability:${Date.now().toString(36)}`;
-      const capability = params.runtimePool.supportsTurnAbort({
-        sessionKey,
-        agentId: typeof request.agentId === "string" ? request.agentId : void 0,
-        channel: "ui",
-        chatId: "web-ui",
-        metadata: {}
-      });
-      return {
-        stopSupported: capability.supported,
-        ...capability.reason ? { stopReason: capability.reason } : {}
-      };
-    },
-    processTurn: async (request) => {
-      const resolved = resolveChatTurnParams(request);
-      const reply = await params.runtimePool.processDirect({
-        content: request.message,
-        sessionKey: resolved.sessionKey,
-        channel: resolved.channel,
-        chatId: resolved.chatId,
-        agentId: resolved.inferredAgentId,
-        metadata: resolved.metadata
-      });
-      return buildTurnResult({
-        reply,
-        sessionKey: resolved.sessionKey,
-        inferredAgentId: resolved.inferredAgentId,
-        model: resolved.model
-      });
-    },
-    startTurnRun: async (request) => {
-      return params.runCoordinator.startRun(request);
-    },
-    listRuns: async (request) => {
-      return params.runCoordinator.listRuns(request);
-    },
-    getRun: async (request) => {
-      return params.runCoordinator.getRun(request);
-    },
-    streamRun: async function* (request) {
-      for await (const event of params.runCoordinator.streamRun(request)) {
-        yield event;
-      }
-    },
-    stopTurn: async (request) => {
-      return await params.runCoordinator.stopRun(request);
-    },
-    processTurnStream: async function* (request) {
-      const run = params.runCoordinator.startRun(request);
-      for await (const event of params.runCoordinator.streamRun({ runId: run.runId })) {
-        yield event;
-      }
-    }
-  };
-}
-function resolveChatTurnParams(params) {
-  const sessionKey = typeof params.sessionKey === "string" && params.sessionKey.trim().length > 0 ? params.sessionKey.trim() : `ui:${Date.now().toString(36)}:${Math.random().toString(36).slice(2, 8)}`;
-  const inferredAgentId = typeof params.agentId === "string" && params.agentId.trim().length > 0 ? params.agentId.trim() : parseAgentScopedSessionKey2(sessionKey)?.agentId;
-  const model = typeof params.model === "string" && params.model.trim().length > 0 ? params.model.trim() : void 0;
-  const metadata = params.metadata && typeof params.metadata === "object" && !Array.isArray(params.metadata) ? { ...params.metadata } : {};
-  if (model) {
-    metadata.model = model;
-  }
-  const runId = typeof params.runId === "string" && params.runId.trim().length > 0 ? params.runId.trim() : void 0;
-  return {
-    runId,
-    sessionKey,
-    inferredAgentId,
-    model,
-    metadata,
-    channel: typeof params.channel === "string" && params.channel.trim().length > 0 ? params.channel : "ui",
-    chatId: typeof params.chatId === "string" && params.chatId.trim().length > 0 ? params.chatId : "web-ui"
-  };
-}
-function buildTurnResult(params) {
-  return {
-    reply: params.reply,
-    sessionKey: params.sessionKey,
-    ...params.inferredAgentId ? { agentId: params.inferredAgentId } : {},
-    ...params.model ? { model: params.model } : {}
-  };
-}
-function resolveUiSessionTypeLabel(sessionType) {
-  if (sessionType === "native") {
-    return "Native";
-  }
-  return sessionType.trim().split(/[-_]+/g).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ") || sessionType;
-}
-
-// src/cli/commands/ui-chat-run-coordinator.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
-import { join as join7 } from "path";
-import {
-  getDataDir as getDataDir9,
-  parseAgentScopedSessionKey as parseAgentScopedSessionKey3,
-  safeFilename
-} from "@nextclaw/core";
-var RUNS_DIR = join7(getDataDir9(), "runs");
-var NON_TERMINAL_STATES = /* @__PURE__ */ new Set(["queued", "running"]);
-var DEFAULT_SESSION_TYPE = "native";
-var SESSION_TYPE_METADATA_KEY = "session_type";
-function createRunId() {
-  const now = Date.now().toString(36);
-  const rand = Math.random().toString(36).slice(2, 10);
-  return `run-${now}-${rand}`;
-}
-function isRecord6(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function readOptionalString3(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  return trimmed || void 0;
-}
-function isAbortError(error) {
-  if (error instanceof DOMException && error.name === "AbortError") {
-    return true;
-  }
-  if (error instanceof Error) {
-    if (error.name === "AbortError") {
-      return true;
-    }
-    const message = error.message.toLowerCase();
-    if (message.includes("aborted") || message.includes("abort")) {
-      return true;
-    }
-  }
-  return false;
-}
-function cloneEvent(event) {
-  return JSON.parse(JSON.stringify(event));
-}
-function hasToolSessionEvent(run) {
-  for (const item of run.events) {
-    if (item.type !== "session_event") {
-      continue;
-    }
-    const message = item.event?.message;
-    if (!message || typeof message.role !== "string") {
-      continue;
-    }
-    const role = message.role.trim().toLowerCase();
-    if (role === "tool" || role === "tool_result" || role === "toolresult" || role === "function") {
-      return true;
-    }
-    if (role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
-      return true;
-    }
-  }
-  return false;
-}
-var UiChatRunCoordinator = class {
-  constructor(options) {
-    this.options = options;
-    mkdirSync5(RUNS_DIR, { recursive: true });
-    this.loadPersistedRuns();
-  }
-  runs = /* @__PURE__ */ new Map();
-  sessionRuns = /* @__PURE__ */ new Map();
-  startRun(input) {
-    const request = this.resolveRequest(input);
-    const resolvedSessionType = this.resolveSessionTypeForRun(request.sessionKey, request.metadata);
-    request.metadata[SESSION_TYPE_METADATA_KEY] = resolvedSessionType;
-    const stopCapability = this.options.runtimePool.supportsTurnAbort({
-      sessionKey: request.sessionKey,
-      agentId: request.agentId,
-      channel: request.channel,
-      chatId: request.chatId,
-      metadata: request.metadata
-    });
-    const run = {
-      runId: request.runId,
-      sessionKey: request.sessionKey,
-      ...request.agentId ? { agentId: request.agentId } : {},
-      ...request.model ? { model: request.model, requestedModel: request.model } : {},
-      state: "queued",
-      requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      stopSupported: stopCapability.supported,
-      ...stopCapability.reason ? { stopReason: stopCapability.reason } : {},
-      events: [],
-      waiters: /* @__PURE__ */ new Set(),
-      abortController: null,
-      cancelRequested: false
-    };
-    this.runs.set(run.runId, run);
-    this.bindRunToSession(run.sessionKey, run.runId);
-    this.syncSessionRunState(run);
-    this.persistRun(run);
-    this.emitRunUpdated(run);
-    void this.executeRun(run, request);
-    return this.toRunView(run);
-  }
-  getRun(params) {
-    const run = this.getRunRecord(params.runId);
-    return run ? this.toRunView(run) : null;
-  }
-  listRuns(params = {}) {
-    const sessionKey = readOptionalString3(params.sessionKey);
-    const stateFilter = Array.isArray(params.states) && params.states.length > 0 ? new Set(params.states) : null;
-    const limit = Number.isFinite(params.limit) ? Math.max(0, Math.trunc(params.limit)) : 0;
-    const records = Array.from(this.runs.values()).filter((run) => {
-      if (sessionKey && run.sessionKey !== sessionKey) {
-        return false;
-      }
-      if (stateFilter && !stateFilter.has(run.state)) {
-        return false;
-      }
-      return true;
-    }).sort((left, right) => Date.parse(right.requestedAt) - Date.parse(left.requestedAt));
-    const total = records.length;
-    const runs = (limit > 0 ? records.slice(0, limit) : records).map((run) => this.toRunView(run));
-    return { runs, total };
-  }
-  async *streamRun(params) {
-    const run = this.getRunRecord(params.runId);
-    if (!run) {
-      throw new Error(`chat run not found: ${params.runId}`);
-    }
-    let cursor = Number.isFinite(params.fromEventIndex) ? Math.max(0, Math.trunc(params.fromEventIndex)) : 0;
-    while (true) {
-      while (cursor < run.events.length) {
-        yield cloneEvent(run.events[cursor]);
-        cursor += 1;
-      }
-      if (!NON_TERMINAL_STATES.has(run.state)) {
-        return;
-      }
-      if (params.signal?.aborted) {
-        return;
-      }
-      await this.waitForRunUpdate(run, params.signal);
-    }
-  }
-  async stopRun(params) {
-    const runId = readOptionalString3(params.runId) ?? "";
-    if (!runId) {
-      return {
-        stopped: false,
-        runId: "",
-        reason: "runId is required"
-      };
-    }
-    const run = this.getRunRecord(runId);
-    if (!run) {
-      return {
-        stopped: false,
-        runId,
-        ...readOptionalString3(params.sessionKey) ? { sessionKey: readOptionalString3(params.sessionKey) } : {},
-        reason: "run not found or already completed"
-      };
-    }
-    const requestedSessionKey = readOptionalString3(params.sessionKey);
-    if (requestedSessionKey && requestedSessionKey !== run.sessionKey) {
-      return {
-        stopped: false,
-        runId,
-        sessionKey: run.sessionKey,
-        reason: "session key mismatch"
-      };
-    }
-    if (!run.stopSupported) {
-      return {
-        stopped: false,
-        runId,
-        sessionKey: run.sessionKey,
-        reason: run.stopReason ?? "run stop is not supported"
-      };
-    }
-    if (!NON_TERMINAL_STATES.has(run.state)) {
-      return {
-        stopped: false,
-        runId,
-        sessionKey: run.sessionKey,
-        reason: `run already ${run.state}`
-      };
-    }
-    run.cancelRequested = true;
-    this.finalizeRunAsStopped(run);
-    if (run.abortController) {
-      run.abortController.abort(new Error("chat turn stopped by user"));
-    }
-    return {
-      stopped: true,
-      runId,
-      sessionKey: run.sessionKey
-    };
-  }
-  resolveRequest(input) {
-    const message = readOptionalString3(input.message) ?? "";
-    const sessionKey = readOptionalString3(input.sessionKey) ?? `ui:${Date.now().toString(36)}:${Math.random().toString(36).slice(2, 8)}`;
-    const explicitAgentId = readOptionalString3(input.agentId);
-    const parsedAgentId = parseAgentScopedSessionKey3(sessionKey)?.agentId;
-    const agentId = explicitAgentId ?? readOptionalString3(parsedAgentId);
-    const model = readOptionalString3(input.model);
-    const metadata = isRecord6(input.metadata) ? { ...input.metadata } : {};
-    if (model) {
-      metadata.model = model;
-    }
-    const runId = readOptionalString3(input.runId) ?? createRunId();
-    return {
-      runId,
-      message,
-      sessionKey,
-      ...agentId ? { agentId } : {},
-      ...model ? { model } : {},
-      metadata,
-      channel: readOptionalString3(input.channel) ?? "ui",
-      chatId: readOptionalString3(input.chatId) ?? "web-ui"
-    };
-  }
-  readRequestedSessionType(metadata) {
-    const value = readOptionalString3(metadata.session_type) ?? readOptionalString3(metadata.sessionType);
-    return value ? value.toLowerCase() : void 0;
-  }
-  readStoredSessionType(metadata) {
-    const value = readOptionalString3(metadata[SESSION_TYPE_METADATA_KEY]);
-    return value ? value.toLowerCase() : DEFAULT_SESSION_TYPE;
-  }
-  countUserMessages(session) {
-    return session.messages.reduce((count, message) => {
-      const role = typeof message.role === "string" ? message.role.trim().toLowerCase() : "";
-      return role === "user" ? count + 1 : count;
-    }, 0);
-  }
-  ensureSessionTypeAvailable(sessionType) {
-    const available = new Set(this.options.runtimePool.listAvailableEngineKinds());
-    available.add(DEFAULT_SESSION_TYPE);
-    if (!available.has(sessionType)) {
-      throw new Error(
-        `session type "${sessionType}" is unavailable. Re-enable the related plugin or create a native session.`
-      );
-    }
-  }
-  resolveSessionTypeForRun(sessionKey, metadata) {
-    const requestedType = this.readRequestedSessionType(metadata);
-    const session = this.options.sessionManager.getOrCreate(sessionKey);
-    const storedType = this.readStoredSessionType(session.metadata);
-    const userMessageCount = this.countUserMessages(session);
-    const locked = userMessageCount > 0;
-    if (locked) {
-      if (requestedType && requestedType !== storedType) {
-        throw new Error(
-          `session type is locked to "${storedType}" after the first user message; create a new session to switch type`
-        );
-      }
-      this.ensureSessionTypeAvailable(storedType);
-      if (session.metadata[SESSION_TYPE_METADATA_KEY] !== storedType) {
-        session.metadata[SESSION_TYPE_METADATA_KEY] = storedType;
-        session.updatedAt = /* @__PURE__ */ new Date();
-        this.options.sessionManager.save(session);
-      }
-      return storedType;
-    }
-    const nextType = requestedType ?? storedType;
-    this.ensureSessionTypeAvailable(nextType);
-    if (session.metadata[SESSION_TYPE_METADATA_KEY] !== nextType) {
-      session.metadata[SESSION_TYPE_METADATA_KEY] = nextType;
-      session.updatedAt = /* @__PURE__ */ new Date();
-      this.options.sessionManager.save(session);
-    }
-    return nextType;
-  }
-  async executeRun(run, request) {
-    if (run.cancelRequested) {
-      this.finalizeRunAsStopped(run);
-      return;
-    }
-    this.transitionState(run, "running");
-    const abortController = run.stopSupported ? new AbortController() : null;
-    run.abortController = abortController;
-    const assistantDeltaParts = [];
-    try {
-      const reply = await this.options.runtimePool.processDirect({
-        content: request.message,
-        sessionKey: request.sessionKey,
-        channel: request.channel,
-        chatId: request.chatId,
-        agentId: request.agentId,
-        metadata: request.metadata,
-        ...abortController ? { abortSignal: abortController.signal } : {},
-        onAssistantDelta: (delta) => {
-          if (run.cancelRequested) {
-            return;
-          }
-          if (typeof delta !== "string" || delta.length === 0) {
-            return;
-          }
-          assistantDeltaParts.push(delta);
-          this.pushStreamEvent(run, { type: "delta", delta });
-        },
-        onSessionEvent: (event) => {
-          if (run.cancelRequested) {
-            return;
-          }
-          this.pushStreamEvent(run, {
-            type: "session_event",
-            event: this.mapSessionEvent(event)
-          });
-        }
-      });
-      if (run.cancelRequested) {
-        this.finalizeRunAsStopped(run);
-        return;
-      }
-      this.pushStreamEvent(run, {
-        type: "final",
-        result: {
-          reply,
-          sessionKey: request.sessionKey,
-          ...request.agentId ? { agentId: request.agentId } : {},
-          ...request.model ? { model: request.model } : {}
-        }
-      });
-      run.reply = reply;
-      this.transitionState(run, "completed");
-    } catch (error) {
-      const aborted = (abortController?.signal.aborted ?? false) || isAbortError(error);
-      if (aborted) {
-        if (run.cancelRequested) {
-          this.finalizeRunAsStopped(run);
-          return;
-        }
-        const partialReply = assistantDeltaParts.join("");
-        const shouldPersistPartialReply = partialReply.trim().length > 0 && !hasToolSessionEvent(run);
-        if (shouldPersistPartialReply) {
-          this.persistAbortedAssistantReply(run.sessionKey, partialReply);
-        }
-        this.pushStreamEvent(run, {
-          type: "final",
-          result: {
-            reply: partialReply,
-            sessionKey: request.sessionKey,
-            ...request.agentId ? { agentId: request.agentId } : {},
-            ...request.model ? { model: request.model } : {}
-          }
-        });
-        run.reply = partialReply;
-        this.transitionState(run, "aborted", {
-          error: abortController?.signal.reason instanceof Error ? abortController.signal.reason.message : readOptionalString3(abortController?.signal.reason)
-        });
-        return;
-      }
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.pushStreamEvent(run, {
-        type: "error",
-        error: errorMessage
-      });
-      this.transitionState(run, "failed", { error: errorMessage });
-    } finally {
-      run.abortController = null;
-      this.persistRun(run);
-      this.notifyRunWaiters(run);
-    }
-  }
-  transitionState(run, next, options = {}) {
-    run.state = next;
-    if (next === "running") {
-      run.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
-    if (!NON_TERMINAL_STATES.has(next)) {
-      run.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
-    if (options.error) {
-      run.error = options.error;
-    } else if (next === "completed") {
-      run.error = void 0;
-    }
-    this.syncSessionRunState(run);
-    this.persistRun(run);
-    this.emitRunUpdated(run);
-    this.notifyRunWaiters(run);
-  }
-  finalizeRunAsStopped(run) {
-    const partialReply = this.collectAssistantReplyFromEvents(run.events);
-    if (!this.hasFinalStreamEvent(run.events)) {
-      this.pushStreamEvent(run, {
-        type: "final",
-        result: {
-          reply: partialReply,
-          sessionKey: run.sessionKey,
-          ...run.agentId ? { agentId: run.agentId } : {},
-          ...run.model ? { model: run.model } : {}
-        }
-      });
-    }
-    run.reply = partialReply;
-    const shouldPersistPartialReply = partialReply.trim().length > 0 && !hasToolSessionEvent(run);
-    if (shouldPersistPartialReply) {
-      this.persistAbortedAssistantReply(run.sessionKey, partialReply);
-    }
-    if (run.state !== "aborted") {
-      this.transitionState(run, "aborted", {
-        error: "chat turn stopped by user"
-      });
-    }
-  }
-  hasFinalStreamEvent(events) {
-    return events.some((event) => event.type === "final");
-  }
-  collectAssistantReplyFromEvents(events) {
-    const chunks = [];
-    for (const event of events) {
-      if (event.type === "delta" && event.delta.length > 0) {
-        chunks.push(event.delta);
-      }
-    }
-    return chunks.join("");
-  }
-  pushStreamEvent(run, event) {
-    run.events.push(event);
-    this.persistRun(run);
-    this.notifyRunWaiters(run);
-    this.emitRunUpdated(run);
-  }
-  waitForRunUpdate(run, signal) {
-    return new Promise((resolve15) => {
-      const wake = () => {
-        cleanup();
-        resolve15();
-      };
-      const onAbort = () => {
-        cleanup();
-        resolve15();
-      };
-      const cleanup = () => {
-        run.waiters.delete(wake);
-        signal?.removeEventListener("abort", onAbort);
-      };
-      run.waiters.add(wake);
-      signal?.addEventListener("abort", onAbort, { once: true });
-    });
-  }
-  notifyRunWaiters(run) {
-    if (run.waiters.size === 0) {
-      return;
-    }
-    const waiters = Array.from(run.waiters);
-    run.waiters.clear();
-    for (const wake of waiters) {
-      wake();
-    }
-  }
-  bindRunToSession(sessionKey, runId) {
-    const existing = this.sessionRuns.get(sessionKey);
-    if (existing) {
-      existing.add(runId);
-      return;
-    }
-    this.sessionRuns.set(sessionKey, /* @__PURE__ */ new Set([runId]));
-  }
-  syncSessionRunState(run) {
-    const session = this.options.sessionManager.getOrCreate(run.sessionKey);
-    const metadata = session.metadata;
-    metadata.ui_last_run_id = run.runId;
-    metadata.ui_last_run_state = run.state;
-    metadata.ui_last_run_updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    if (NON_TERMINAL_STATES.has(run.state)) {
-      metadata.ui_active_run_id = run.runId;
-      metadata.ui_run_state = run.state;
-      metadata.ui_run_requested_at = run.requestedAt;
-      if (run.startedAt) {
-        metadata.ui_run_started_at = run.startedAt;
-      }
-    } else if (metadata.ui_active_run_id === run.runId) {
-      delete metadata.ui_active_run_id;
-      delete metadata.ui_run_state;
-      delete metadata.ui_run_requested_at;
-      delete metadata.ui_run_started_at;
-    }
-    session.updatedAt = /* @__PURE__ */ new Date();
-    this.options.sessionManager.save(session);
-  }
-  persistAbortedAssistantReply(sessionKey, partialReply) {
-    const session = this.options.sessionManager.getOrCreate(sessionKey);
-    const latest = session.messages.length > 0 ? session.messages[session.messages.length - 1] : null;
-    if (latest?.role === "assistant" && typeof latest.content === "string" && latest.content === partialReply) {
-      return;
-    }
-    this.options.sessionManager.addMessage(session, "assistant", partialReply);
-    this.options.sessionManager.save(session);
-  }
-  mapSessionEvent(event) {
-    const raw = event.data?.message;
-    const messageRecord = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
-    const message = messageRecord && typeof messageRecord.role === "string" ? {
-      role: messageRecord.role,
-      content: messageRecord.content,
-      timestamp: typeof messageRecord.timestamp === "string" ? messageRecord.timestamp : event.timestamp,
-      ...typeof messageRecord.name === "string" ? { name: messageRecord.name } : {},
-      ...typeof messageRecord.tool_call_id === "string" ? { tool_call_id: messageRecord.tool_call_id } : {},
-      ...Array.isArray(messageRecord.tool_calls) ? { tool_calls: messageRecord.tool_calls } : {},
-      ...typeof messageRecord.reasoning_content === "string" ? { reasoning_content: messageRecord.reasoning_content } : {}
-    } : void 0;
-    return {
-      seq: event.seq,
-      type: event.type,
-      timestamp: event.timestamp,
-      ...message ? { message } : {}
-    };
-  }
-  emitRunUpdated(run) {
-    this.options.onRunUpdated?.(this.toRunView(run));
-  }
-  toRunView(run) {
-    return {
-      runId: run.runId,
-      sessionKey: run.sessionKey,
-      ...run.agentId ? { agentId: run.agentId } : {},
-      ...run.model ? { model: run.model } : {},
-      state: run.state,
-      requestedAt: run.requestedAt,
-      ...run.startedAt ? { startedAt: run.startedAt } : {},
-      ...run.completedAt ? { completedAt: run.completedAt } : {},
-      stopSupported: run.stopSupported,
-      ...run.stopReason ? { stopReason: run.stopReason } : {},
-      ...run.error ? { error: run.error } : {},
-      ...typeof run.reply === "string" ? { reply: run.reply } : {},
-      eventCount: run.events.length
-    };
-  }
-  getRunPath(runId) {
-    return join7(RUNS_DIR, `${safeFilename(runId)}.json`);
-  }
-  persistRun(run) {
-    const persisted = {
-      runId: run.runId,
-      sessionKey: run.sessionKey,
-      ...run.agentId ? { agentId: run.agentId } : {},
-      ...run.model ? { model: run.model } : {},
-      state: run.state,
-      requestedAt: run.requestedAt,
-      ...run.startedAt ? { startedAt: run.startedAt } : {},
-      ...run.completedAt ? { completedAt: run.completedAt } : {},
-      stopSupported: run.stopSupported,
-      ...run.stopReason ? { stopReason: run.stopReason } : {},
-      ...run.error ? { error: run.error } : {},
-      ...typeof run.reply === "string" ? { reply: run.reply } : {},
-      events: run.events
-    };
-    writeFileSync5(this.getRunPath(run.runId), `${JSON.stringify(persisted, null, 2)}
-`);
-  }
-  loadPersistedRuns() {
-    if (!existsSync11(RUNS_DIR)) {
-      return;
-    }
-    for (const entry of readdirSync2(RUNS_DIR, { withFileTypes: true })) {
-      if (!entry.isFile() || !entry.name.endsWith(".json")) {
-        continue;
-      }
-      const path2 = join7(RUNS_DIR, entry.name);
-      try {
-        const parsed = JSON.parse(readFileSync9(path2, "utf-8"));
-        const runId = readOptionalString3(parsed.runId);
-        const sessionKey = readOptionalString3(parsed.sessionKey);
-        if (!runId || !sessionKey) {
-          continue;
-        }
-        const state = this.normalizeRunState(parsed.state);
-        const events = Array.isArray(parsed.events) ? parsed.events : [];
-        const run = {
-          runId,
-          sessionKey,
-          ...readOptionalString3(parsed.agentId) ? { agentId: readOptionalString3(parsed.agentId) } : {},
-          ...readOptionalString3(parsed.model) ? { model: readOptionalString3(parsed.model) } : {},
-          state,
-          requestedAt: readOptionalString3(parsed.requestedAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
-          ...readOptionalString3(parsed.startedAt) ? { startedAt: readOptionalString3(parsed.startedAt) } : {},
-          ...readOptionalString3(parsed.completedAt) ? { completedAt: readOptionalString3(parsed.completedAt) } : {},
-          stopSupported: Boolean(parsed.stopSupported),
-          ...readOptionalString3(parsed.stopReason) ? { stopReason: readOptionalString3(parsed.stopReason) } : {},
-          ...readOptionalString3(parsed.error) ? { error: readOptionalString3(parsed.error) } : {},
-          ...typeof parsed.reply === "string" ? { reply: parsed.reply } : {},
-          events,
-          waiters: /* @__PURE__ */ new Set(),
-          abortController: null,
-          cancelRequested: false
-        };
-        if (NON_TERMINAL_STATES.has(run.state)) {
-          run.state = "failed";
-          run.error = run.error ?? "run interrupted by service restart";
-          run.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-          this.persistRun(run);
-        }
-        this.runs.set(run.runId, run);
-        this.bindRunToSession(run.sessionKey, run.runId);
-      } catch {
-      }
-    }
-  }
-  normalizeRunState(value) {
-    if (value === "queued" || value === "running" || value === "completed" || value === "failed" || value === "aborted") {
-      return value;
-    }
-    return "failed";
-  }
-  getRunRecord(runId) {
-    const normalized = readOptionalString3(runId);
-    if (!normalized) {
-      return null;
-    }
-    return this.runs.get(normalized) ?? null;
-  }
-};
-
 // src/cli/commands/service-gateway-startup.ts
 async function startUiShell(params) {
+  logStartupTrace("service.start_ui_shell.begin");
   if (!params.uiConfig.enabled) {
     return null;
   }
   let publishUiEvent = null;
-  params.runtimePool.setSystemSessionUpdatedHandler(({ sessionKey, message }) => {
-    if (!publishUiEvent) {
-      return;
-    }
-    if (!message.chatId.startsWith("ui:")) {
-      return;
-    }
-    publishUiEvent({
-      type: "session.updated",
-      payload: {
-        sessionKey
-      }
-    });
-  });
-  const runCoordinator = new UiChatRunCoordinator({
-    runtimePool: params.runtimePool,
-    sessionManager: params.sessionManager,
-    onRunUpdated: (run) => {
-      publishUiEvent?.({ type: "run.updated", payload: { run } });
-    }
-  });
   const deferredNcpAgent = createDeferredUiNcpAgent();
   const uiServer = startUiServer({
     host: params.uiConfig.host,
@@ -8740,11 +8085,7 @@ async function startUiShell(params) {
     remoteAccess: params.remoteAccess,
     getPluginChannelBindings: params.getPluginChannelBindings,
     getPluginUiMetadata: params.getPluginUiMetadata,
-    ncpAgent: deferredNcpAgent.agent,
-    chatRuntime: createServiceUiChatRuntime({
-      runtimePool: params.runtimePool,
-      runCoordinator
-    })
+    ncpAgent: deferredNcpAgent.agent
   });
   publishUiEvent = uiServer.publish;
   const uiUrl = `http://${uiServer.host}:${uiServer.port}`;
@@ -8755,23 +8096,34 @@ async function startUiShell(params) {
   if (params.openBrowserWindow) {
     openBrowser(uiUrl);
   }
+  logStartupTrace("service.start_ui_shell.ready", {
+    host: uiServer.host,
+    port: uiServer.port
+  });
   return {
-    deferredNcpAgent
+    deferredNcpAgent,
+    publish: (event) => {
+      publishUiEvent?.(event);
+    }
   };
 }
 async function startDeferredGatewayStartup(params) {
+  logStartupTrace("service.deferred_startup.begin");
   if (params.uiStartup) {
     try {
-      const ncpAgent = await createUiNcpAgent({
-        bus: params.bus,
-        providerManager: params.providerManager,
-        sessionManager: params.sessionManager,
-        cronService: params.cronService,
-        gatewayController: params.gatewayController,
-        getConfig: params.getConfig,
-        getExtensionRegistry: params.getExtensionRegistry,
-        resolveMessageToolHints: ({ channel, accountId }) => params.resolveMessageToolHints({ channel, accountId })
-      });
+      const ncpAgent = await measureStartupAsync(
+        "service.deferred_startup.create_ui_ncp_agent",
+        async () => await createUiNcpAgent({
+          bus: params.bus,
+          providerManager: params.providerManager,
+          sessionManager: params.sessionManager,
+          cronService: params.cronService,
+          gatewayController: params.gatewayController,
+          getConfig: params.getConfig,
+          getExtensionRegistry: params.getExtensionRegistry,
+          resolveMessageToolHints: ({ channel, accountId }) => params.resolveMessageToolHints({ channel, accountId })
+        })
+      );
       params.onNcpAgentReady(ncpAgent);
       params.uiStartup.deferredNcpAgent.activate(ncpAgent);
       console.log("\u2713 UI NCP agent: ready");
@@ -8779,10 +8131,11 @@ async function startDeferredGatewayStartup(params) {
       console.error(`UI NCP agent startup failed: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  await params.startPluginGateways();
-  await params.startChannels();
-  await params.wakeFromRestartSentinel();
+  await measureStartupAsync("service.deferred_startup.start_plugin_gateways", params.startPluginGateways);
+  await measureStartupAsync("service.deferred_startup.start_channels", params.startChannels);
+  await measureStartupAsync("service.deferred_startup.wake_restart_sentinel", params.wakeFromRestartSentinel);
   console.log("\u2713 Deferred startup: plugin gateways and channels settled");
+  logStartupTrace("service.deferred_startup.end");
 }
 async function runGatewayRuntimeLoop(params) {
   let startupTask = null;
@@ -8799,6 +8152,18 @@ async function runGatewayRuntimeLoop(params) {
   }
 }
 
+// src/cli/commands/service-ui-shell-grace.ts
+import { setTimeout as delay } from "timers/promises";
+var DEFAULT_UI_SHELL_GRACE_MS = 3e3;
+async function waitForUiShellGraceWindow(uiStartup) {
+  if (!uiStartup) {
+    return;
+  }
+  await measureStartupAsync("service.ui_shell_grace_window", async () => {
+    await delay(DEFAULT_UI_SHELL_GRACE_MS);
+  });
+}
+
 // src/cli/commands/service.ts
 var {
   APP_NAME: APP_NAME3,
@@ -8812,7 +8177,7 @@ var {
   MessageBus: MessageBus2,
   resolveConfigSecrets: resolveConfigSecrets4,
   SessionManager: SessionManager2,
-  parseAgentScopedSessionKey: parseAgentScopedSessionKey4
+  parseAgentScopedSessionKey: parseAgentScopedSessionKey2
 } = NextclawCore2;
 function createSkillsLoader(workspace) {
   const ctor = NextclawCore2.SkillsLoader;
@@ -8828,19 +8193,67 @@ var ServiceCommands = class {
   applyLiveConfigReload = null;
   liveUiNcpAgent = null;
   async startGateway(options = {}) {
+    logStartupTrace("service.start_gateway.begin");
     this.applyLiveConfigReload = null;
     this.liveUiNcpAgent = null;
-    const gateway = createGatewayStartupContext({
-      uiOverrides: options.uiOverrides,
-      allowMissingProvider: options.allowMissingProvider,
-      uiStaticDir: options.uiStaticDir,
-      makeProvider: (config2, providerOptions) => providerOptions?.allowMissing === true ? this.makeProvider(config2, { allowMissing: true }) : this.makeProvider(config2),
-      makeMissingProvider: (config2) => this.makeMissingProvider(config2),
-      requestRestart: (params) => this.deps.requestRestart(params)
-    });
-    this.applyLiveConfigReload = gateway.applyLiveConfigReload;
-    let { pluginRegistry, pluginChannelBindings, extensionRegistry } = gateway;
+    const shellContext = measureStartupSync(
+      "service.create_gateway_shell_context",
+      () => createGatewayShellContext({ uiOverrides: options.uiOverrides, uiStaticDir: options.uiStaticDir })
+    );
+    const applyLiveConfigReload = async () => {
+      await this.applyLiveConfigReload?.();
+    };
+    let pluginChannelBindings = [];
+    let pluginUiMetadata = [];
     let pluginGatewayHandles = [];
+    const marketplaceInstaller = new ServiceMarketplaceInstaller({
+      applyLiveConfigReload,
+      runCliSubcommand: (args) => this.runCliSubcommand(args),
+      installBuiltinSkill: (slug, force) => this.installBuiltinMarketplaceSkill(slug, force)
+    }).createInstaller();
+    const remoteAccess = createRemoteAccessHost({
+      serviceCommands: this,
+      requestRestart: this.deps.requestRestart,
+      uiConfig: shellContext.uiConfig,
+      remoteModule: shellContext.remoteModule
+    });
+    const uiStartup = await measureStartupAsync(
+      "service.start_ui_shell",
+      async () => await startUiShell({
+        uiConfig: shellContext.uiConfig,
+        uiStaticDir: shellContext.uiStaticDir,
+        cronService: shellContext.cron,
+        getConfig: () => resolveConfigSecrets4(loadConfig18(), { configPath: shellContext.runtimeConfigPath }),
+        configPath: getConfigPath10(),
+        productVersion: getPackageVersion(),
+        getPluginChannelBindings: () => pluginChannelBindings,
+        getPluginUiMetadata: () => pluginUiMetadata,
+        marketplace: { apiBaseUrl: process.env.NEXTCLAW_MARKETPLACE_API_BASE, installer: marketplaceInstaller },
+        remoteAccess,
+        openBrowserWindow: shellContext.uiConfig.open,
+        applyLiveConfigReload
+      })
+    );
+    await waitForUiShellGraceWindow(uiStartup);
+    await waitForNextTick();
+    const gateway = measureStartupSync(
+      "service.create_gateway_startup_context",
+      () => createGatewayStartupContext({
+        shellContext,
+        uiOverrides: options.uiOverrides,
+        allowMissingProvider: options.allowMissingProvider,
+        uiStaticDir: options.uiStaticDir,
+        makeProvider: (config2, providerOptions) => providerOptions?.allowMissing === true ? this.makeProvider(config2, { allowMissing: true }) : this.makeProvider(config2),
+        makeMissingProvider: (config2) => this.makeMissingProvider(config2),
+        requestRestart: (params) => this.deps.requestRestart(params)
+      })
+    );
+    this.applyLiveConfigReload = gateway.applyLiveConfigReload;
+    let { pluginRegistry, extensionRegistry } = gateway;
+    pluginChannelBindings = gateway.pluginChannelBindings;
+    pluginUiMetadata = getPluginUiMetadataFromRegistry(pluginRegistry);
+    uiStartup?.publish({ type: "config.updated", payload: { path: "channels" } });
+    uiStartup?.publish({ type: "config.updated", payload: { path: "plugins" } });
     gateway.reloader.setApplyAgentRuntimeConfig((nextConfig) => gateway.runtimePool.applyRuntimeConfig(nextConfig));
     gateway.reloader.setReloadPlugins(async ({ config: nextConfig, changedPaths }) => {
       const result = await reloadServicePlugins({
@@ -8873,49 +8286,19 @@ var ServiceCommands = class {
       runtimeConfigPath: gateway.runtimeConfigPath,
       pluginChannelBindings
     });
-    if (gateway.reloader.getChannels().enabledChannels.length) {
-      console.log(`\u2713 Channels enabled: ${gateway.reloader.getChannels().enabledChannels.join(", ")}`);
-    } else {
-      console.log("Warning: No channels enabled");
-    }
-    const marketplaceInstaller = new ServiceMarketplaceInstaller({
-      applyLiveConfigReload: this.applyLiveConfigReload ?? void 0,
-      runCliSubcommand: (args) => this.runCliSubcommand(args),
-      installBuiltinSkill: (slug, force) => this.installBuiltinMarketplaceSkill(slug, force)
-    }).createInstaller();
-    const remoteAccess = createRemoteAccessHost({
-      serviceCommands: this,
-      requestRestart: this.deps.requestRestart,
-      uiConfig: gateway.uiConfig,
-      remoteModule: gateway.remoteModule
-    });
-    const uiStartup = await startUiShell({
-      uiConfig: gateway.uiConfig,
-      uiStaticDir: gateway.uiStaticDir,
-      cronService: gateway.cron,
-      runtimePool: gateway.runtimePool,
-      sessionManager: gateway.sessionManager,
-      bus: gateway.bus,
-      getConfig: () => resolveConfigSecrets4(loadConfig18(), { configPath: gateway.runtimeConfigPath }),
-      configPath: getConfigPath10(),
-      productVersion: getPackageVersion(),
-      getPluginChannelBindings: () => pluginChannelBindings,
-      getPluginUiMetadata: () => getPluginUiMetadataFromRegistry(pluginRegistry),
-      marketplace: {
-        apiBaseUrl: process.env.NEXTCLAW_MARKETPLACE_API_BASE,
-        installer: marketplaceInstaller
-      },
-      remoteAccess,
-      openBrowserWindow: gateway.uiConfig.open,
-      applyLiveConfigReload: this.applyLiveConfigReload ?? void 0
-    });
-    await startGatewaySupportServices({
-      cronJobs: gateway.cron.status().jobs,
-      remoteModule: gateway.remoteModule,
-      watchConfigFile: () => this.watchConfigFile(gateway.reloader),
-      startCron: () => gateway.cron.start(),
-      startHeartbeat: () => gateway.heartbeat.start()
-    });
+    if (gateway.reloader.getChannels().enabledChannels.length) console.log(`\u2713 Channels enabled: ${gateway.reloader.getChannels().enabledChannels.join(", ")}`);
+    else console.log("Warning: No channels enabled");
+    await measureStartupAsync(
+      "service.start_gateway_support_services",
+      async () => await startGatewaySupportServices({
+        cronJobs: gateway.cron.status().jobs,
+        remoteModule: gateway.remoteModule,
+        watchConfigFile: () => this.watchConfigFile(gateway.reloader),
+        startCron: () => gateway.cron.start(),
+        startHeartbeat: () => gateway.heartbeat.start()
+      })
+    );
+    logStartupTrace("service.start_gateway.runtime_loop_begin");
     await runGatewayRuntimeLoop({
       runtimePool: gateway.runtimePool,
       startDeferredStartup: () => startDeferredGatewayStartup({
@@ -8964,6 +8347,7 @@ var ServiceCommands = class {
         setPluginRuntimeBridge2(null);
       }
     });
+    logStartupTrace("service.start_gateway.end");
   }
   normalizeOptionalString(value) {
     if (typeof value !== "string") {
@@ -9058,7 +8442,7 @@ var ServiceCommands = class {
     }
     const sessionKey = sentinelSessionKey ?? fallbackSessionKey ?? "cli:default";
     const parsedSession = parseSessionKey(sessionKey);
-    const parsedAgentSession = parseAgentScopedSessionKey4(sessionKey);
+    const parsedAgentSession = parseAgentScopedSessionKey2(sessionKey);
     const parsedSessionRoute = parsedSession && parsedSession.channel !== "agent" ? parsedSession : null;
     const context = payload.deliveryContext;
     const channel = this.normalizeOptionalString(context?.channel) ?? parsedSessionRoute?.channel ?? this.normalizeOptionalString((params.sessionManager.getIfExists(sessionKey)?.metadata ?? {}).last_channel);
@@ -9168,7 +8552,7 @@ var ServiceCommands = class {
     }
     const logPath = resolveServiceLogPath();
     const logDir = resolve12(logPath, "..");
-    mkdirSync6(logDir, { recursive: true });
+    mkdirSync5(logDir, { recursive: true });
     const logFd = openSync2(logPath, "a");
     const readinessTimeoutMs = this.resolveStartupTimeoutMs(options.startupTimeoutMs);
     const quickPhaseTimeoutMs = Math.min(8e3, readinessTimeoutMs);
@@ -9557,9 +8941,9 @@ var ServiceCommands = class {
   }
   installBuiltinMarketplaceSkill(slug, force) {
     const workspace = getWorkspacePath11(loadConfig18().agents.defaults.workspace);
-    const destination = join8(workspace, "skills", slug);
-    const destinationSkillFile = join8(destination, "SKILL.md");
-    if (existsSync12(destinationSkillFile) && !force) {
+    const destination = join7(workspace, "skills", slug);
+    const destinationSkillFile = join7(destination, "SKILL.md");
+    if (existsSync11(destinationSkillFile) && !force) {
       return {
         message: `${slug} is already installed`
       };
@@ -9567,14 +8951,14 @@ var ServiceCommands = class {
     const loader = createSkillsLoader(workspace);
     const builtin = (loader?.listSkills(false) ?? []).find((skill) => skill.name === slug && skill.source === "builtin");
     if (!builtin) {
-      if (existsSync12(destinationSkillFile)) {
+      if (existsSync11(destinationSkillFile)) {
         return {
           message: `${slug} is already installed`
         };
       }
       return null;
     }
-    mkdirSync6(join8(workspace, "skills"), { recursive: true });
+    mkdirSync5(join7(workspace, "skills"), { recursive: true });
     cpSync2(dirname3(builtin.path), destination, { recursive: true, force: true });
     return {
       message: `Installed skill: ${slug}`
@@ -9634,11 +9018,11 @@ ${stderr}`.trim();
 };
 
 // src/cli/workspace.ts
-import { cpSync as cpSync3, existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync10, readdirSync as readdirSync3, rmSync as rmSync6, writeFileSync as writeFileSync6 } from "fs";
+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 join9, resolve as resolve13 } from "path";
+import { dirname as dirname4, join as join8, resolve as resolve13 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { APP_NAME as APP_NAME4, getDataDir as getDataDir10 } from "@nextclaw/core";
+import { APP_NAME as APP_NAME4, getDataDir as getDataDir9 } from "@nextclaw/core";
 import { spawnSync as spawnSync3 } from "child_process";
 var WorkspaceManager = class {
   constructor(logo) {
@@ -9666,30 +9050,30 @@ var WorkspaceManager = class {
       { source: "memory/MEMORY.md", target: "memory/MEMORY.md" }
     ];
     for (const entry of templateFiles) {
-      const filePath = join9(workspace, entry.target);
-      if (!force && existsSync13(filePath)) {
+      const filePath = join8(workspace, entry.target);
+      if (!force && existsSync12(filePath)) {
         continue;
       }
-      const templatePath = join9(templateDir, entry.source);
-      if (!existsSync13(templatePath)) {
+      const templatePath = join8(templateDir, entry.source);
+      if (!existsSync12(templatePath)) {
         console.warn(`Warning: Template file missing: ${templatePath}`);
         continue;
       }
-      const raw = readFileSync10(templatePath, "utf-8");
+      const raw = readFileSync9(templatePath, "utf-8");
       const content = raw.replace(/\$\{APP_NAME\}/g, APP_NAME4);
-      mkdirSync7(dirname4(filePath), { recursive: true });
-      writeFileSync6(filePath, content);
+      mkdirSync6(dirname4(filePath), { recursive: true });
+      writeFileSync5(filePath, content);
       created.push(entry.target);
     }
-    const memoryDir = join9(workspace, "memory");
-    if (!existsSync13(memoryDir)) {
-      mkdirSync7(memoryDir, { recursive: true });
-      created.push(join9("memory", ""));
+    const memoryDir = join8(workspace, "memory");
+    if (!existsSync12(memoryDir)) {
+      mkdirSync6(memoryDir, { recursive: true });
+      created.push(join8("memory", ""));
     }
-    const skillsDir = join9(workspace, "skills");
-    if (!existsSync13(skillsDir)) {
-      mkdirSync7(skillsDir, { recursive: true });
-      created.push(join9("skills", ""));
+    const skillsDir = join8(workspace, "skills");
+    if (!existsSync12(skillsDir)) {
+      mkdirSync6(skillsDir, { recursive: true });
+      created.push(join8("skills", ""));
     }
     const seeded = this.seedBuiltinSkills(skillsDir, { force });
     if (seeded > 0) {
@@ -9704,16 +9088,16 @@ var WorkspaceManager = class {
     }
     const force = Boolean(options.force);
     let seeded = 0;
-    for (const entry of readdirSync3(sourceDir, { withFileTypes: true })) {
+    for (const entry of readdirSync2(sourceDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const src = join9(sourceDir, entry.name);
-      if (!existsSync13(join9(src, "SKILL.md"))) {
+      const src = join8(sourceDir, entry.name);
+      if (!existsSync12(join8(src, "SKILL.md"))) {
         continue;
       }
-      const dest = join9(targetDir, entry.name);
-      if (!force && existsSync13(dest)) {
+      const dest = join8(targetDir, entry.name);
+      if (!force && existsSync12(dest)) {
         continue;
       }
       try {
@@ -9731,12 +9115,12 @@ var WorkspaceManager = class {
       const require3 = createRequire2(import.meta.url);
       const entry = require3.resolve("@nextclaw/core");
       const pkgRoot = resolve13(dirname4(entry), "..");
-      const distSkills = join9(pkgRoot, "dist", "skills");
-      if (existsSync13(distSkills)) {
+      const distSkills = join8(pkgRoot, "dist", "skills");
+      if (existsSync12(distSkills)) {
         return distSkills;
       }
-      const srcSkills = join9(pkgRoot, "src", "agent", "skills");
-      if (existsSync13(srcSkills)) {
+      const srcSkills = join8(pkgRoot, "src", "agent", "skills");
+      if (existsSync12(srcSkills)) {
         return srcSkills;
       }
       return null;
@@ -9751,17 +9135,17 @@ var WorkspaceManager = class {
     }
     const cliDir = resolve13(fileURLToPath4(new URL(".", import.meta.url)));
     const pkgRoot = resolve13(cliDir, "..", "..");
-    const candidates = [join9(pkgRoot, "templates")];
+    const candidates = [join8(pkgRoot, "templates")];
     for (const candidate of candidates) {
-      if (existsSync13(candidate)) {
+      if (existsSync12(candidate)) {
         return candidate;
       }
     }
     return null;
   }
   getBridgeDir() {
-    const userBridge = join9(getDataDir10(), "bridge");
-    if (existsSync13(join9(userBridge, "dist", "index.js"))) {
+    const userBridge = join8(getDataDir9(), "bridge");
+    if (existsSync12(join8(userBridge, "dist", "index.js"))) {
       return userBridge;
     }
     if (!which("npm")) {
@@ -9770,12 +9154,12 @@ var WorkspaceManager = class {
     }
     const cliDir = resolve13(fileURLToPath4(new URL(".", import.meta.url)));
     const pkgRoot = resolve13(cliDir, "..", "..");
-    const pkgBridge = join9(pkgRoot, "bridge");
-    const srcBridge = join9(pkgRoot, "..", "..", "bridge");
+    const pkgBridge = join8(pkgRoot, "bridge");
+    const srcBridge = join8(pkgRoot, "..", "..", "bridge");
     let source = null;
-    if (existsSync13(join9(pkgBridge, "package.json"))) {
+    if (existsSync12(join8(pkgBridge, "package.json"))) {
       source = pkgBridge;
-    } else if (existsSync13(join9(srcBridge, "package.json"))) {
+    } else if (existsSync12(join8(srcBridge, "package.json"))) {
       source = srcBridge;
     }
     if (!source) {
@@ -9783,8 +9167,8 @@ var WorkspaceManager = class {
       process.exit(1);
     }
     console.log(`${this.logo} Setting up bridge...`);
-    mkdirSync7(resolve13(userBridge, ".."), { recursive: true });
-    if (existsSync13(userBridge)) {
+    mkdirSync6(resolve13(userBridge, ".."), { recursive: true });
+    if (existsSync12(userBridge)) {
       rmSync6(userBridge, { recursive: true, force: true });
     }
     cpSync3(source, userBridge, {
@@ -9840,42 +9224,44 @@ var CliRuntime = class {
   remote;
   diagnosticsCommands;
   constructor(options = {}) {
+    logStartupTrace("cli.runtime.constructor.begin");
     this.logo = options.logo ?? LOGO;
-    this.workspaceManager = new WorkspaceManager(this.logo);
-    this.serviceCommands = new ServiceCommands({
+    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)
-    });
-    this.configCommands = new ConfigCommands({
+    }));
+    this.configCommands = measureStartupSync("cli.runtime.config_commands", () => new ConfigCommands({
       requestRestart: (params) => this.requestRestart(params)
-    });
-    this.mcpCommands = new McpCommands();
-    this.secretsCommands = new SecretsCommands({
+    }));
+    this.mcpCommands = measureStartupSync("cli.runtime.mcp_commands", () => new McpCommands());
+    this.secretsCommands = measureStartupSync("cli.runtime.secrets_commands", () => new SecretsCommands({
       requestRestart: (params) => this.requestRestart(params)
-    });
-    this.pluginCommands = new PluginCommands();
-    this.channelCommands = new ChannelCommands({
+    }));
+    this.pluginCommands = measureStartupSync("cli.runtime.plugin_commands", () => new PluginCommands());
+    this.channelCommands = measureStartupSync("cli.runtime.channel_commands", () => new ChannelCommands({
       logo: this.logo,
       getBridgeDir: () => this.workspaceManager.getBridgeDir(),
       requestRestart: (params) => this.requestRestart(params)
-    });
-    this.cronCommands = new CronCommands();
-    this.platformAuthCommands = new PlatformAuthCommands();
-    this.remoteCommands = new RemoteCommands();
-    this.remote = new RemoteRuntimeActions({
+    }));
+    this.cronCommands = measureStartupSync("cli.runtime.cron_commands", () => new CronCommands());
+    this.platformAuthCommands = measureStartupSync("cli.runtime.platform_auth_commands", () => new PlatformAuthCommands());
+    this.remoteCommands = measureStartupSync("cli.runtime.remote_commands", () => new RemoteCommands());
+    this.remote = measureStartupSync("cli.runtime.remote_runtime_actions", () => new RemoteRuntimeActions({
       appName: APP_NAME5,
       initAuto: (source) => this.init({ source, auto: true }),
       remoteCommands: this.remoteCommands,
       restartBackgroundService: (reason) => this.restartBackgroundService(reason),
       hasRunningManagedService: hasRunningNextclawManagedService
-    });
-    this.diagnosticsCommands = new DiagnosticsCommands({ logo: this.logo });
-    this.restartCoordinator = new RestartCoordinator({
+    }));
+    this.diagnosticsCommands = measureStartupSync("cli.runtime.diagnostics_commands", () => new DiagnosticsCommands({ logo: this.logo }));
+    this.restartCoordinator = measureStartupSync("cli.runtime.restart_coordinator", () => new RestartCoordinator({
       readServiceState,
       isProcessRunning,
       currentPid: () => process.pid,
       restartBackgroundService: async (reason) => this.restartBackgroundService(reason),
       scheduleProcessExit: (delayMs, reason) => this.scheduleProcessExit(delayMs, reason)
-    });
+    }));
+    logStartupTrace("cli.runtime.constructor.end");
   }
   get version() {
     return getPackageVersion();
@@ -9933,7 +9319,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 = resolve14(getDataDir11(), "run", "service.json");
+    const serviceStatePath = resolve14(getDataDir10(), "run", "service.json");
     const helperScript = [
       'const { spawnSync } = require("node:child_process");',
       'const { readFileSync } = require("node:fs");',
@@ -10065,9 +9451,9 @@ var CliRuntime = class {
     const createdConfig = initializeConfigIfMissing(configPath);
     const config2 = loadConfig19();
     const workspaceSetting = config2.agents.defaults.workspace;
-    const workspacePath = !workspaceSetting || workspaceSetting === DEFAULT_WORKSPACE_PATH ? join10(getDataDir11(), DEFAULT_WORKSPACE_DIR) : expandHome2(workspaceSetting);
-    const workspaceExisted = existsSync14(workspacePath);
-    mkdirSync8(workspacePath, { recursive: true });
+    const workspacePath = !workspaceSetting || workspaceSetting === DEFAULT_WORKSPACE_PATH ? join9(getDataDir10(), DEFAULT_WORKSPACE_DIR) : expandHome2(workspaceSetting);
+    const workspaceExisted = existsSync13(workspacePath);
+    mkdirSync7(workspacePath, { recursive: true });
     const templateResult = this.workspaceManager.createWorkspaceTemplates(
       workspacePath,
       { force }
@@ -10258,10 +9644,10 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
         `${this.logo} Interactive mode (type exit or Ctrl+C to quit)
 `
       );
-      const historyFile = join10(getDataDir11(), "history", "cli_history");
+      const historyFile = join9(getDataDir10(), "history", "cli_history");
       const historyDir = resolve14(historyFile, "..");
-      mkdirSync8(historyDir, { recursive: true });
-      const history = existsSync14(historyFile) ? readFileSync11(historyFile, "utf-8").split("\n").filter(Boolean) : [];
+      mkdirSync7(historyDir, { recursive: true });
+      const history = existsSync13(historyFile) ? readFileSync10(historyFile, "utf-8").split("\n").filter(Boolean) : [];
       const rl = createInterface3({
         input: process.stdin,
         output: process.stdout
@@ -10270,7 +9656,7 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
         const merged = history.concat(
           rl.history ?? []
         );
-        writeFileSync7(historyFile, merged.join("\n"));
+        writeFileSync6(historyFile, merged.join("\n"));
         process.exit(0);
       });
       let running = true;
@@ -10496,8 +9882,9 @@ ${this.logo} ${APP_NAME5} is ready! (${source})`);
 };
 
 // src/cli/index.ts
+logStartupTrace("cli.index.module_loaded");
 var program = new Command();
-var runtime = new CliRuntime({ logo: LOGO });
+var runtime = measureStartupSync("cli.runtime.construct", () => new CliRuntime({ logo: LOGO }));
 program.name(APP_NAME6).description(`${LOGO} ${APP_NAME6} - ${APP_TAGLINE}`).version(getPackageVersion(), "-v, --version", "show version");
 program.command("onboard").description(`Initialize ${APP_NAME6} configuration and workspace`).action(async () => runtime.onboard());
 program.command("init").description(`Initialize ${APP_NAME6} configuration and workspace`).option("-f, --force", "Overwrite existing template files").action(async (opts) => runtime.init({ force: Boolean(opts.force) }));