@nextclaw/kernel 0.1.7 → 0.1.9

package/dist/index.d.ts

@@ -1,14 +1,11 @@
 import { a as getUnsignedUpdateManifest, c as UpdateBlockReason, d as UpdateSnapshot, f as UpdateStatus, i as UpdateManifestReader, l as UpdatePreferences, n as UpdateHostKind, o as serializeUnsignedUpdateManifest, r as UpdateManifest, s as InstallationKind, t as UnsignedUpdateManifest, u as UpdateProgress } from "./update-manifest.types-DLWDvs_v.js";
-import { BaseChannel, ChannelManager, ChannelManager as ChannelManager$1, Config, ContextCompactionPlan, ContextWindowSnapshot, CronService, Disposable, ExtensionRegistry, GatewayController, InboundAttachment, InboundMessage, LLMProvider, LLMResponse, LLMStreamEvent, MessageBus, SearchConfig, SessionManager, SessionMessage, SessionRequestDispatcher, SessionRequestManager, SessionRequestRecord, SessionRequestToolResult, SessionSearchManager, SpawnSessionAndRequestParams, ThinkingLevel, buildCompressingCompactionCheckpoint } from "@nextclaw/core";
-import * as _$_nextclaw_shared0 from "@nextclaw/shared";
+import { BaseChannel, ChannelManager, ChannelManager as ChannelManager$1, Config, ContextCompactionPlan, ContextWindowSnapshot, CronService, Disposable, ExtensionRegistry, ExtensionToolContext, GatewayController, InboundAttachment, InboundMessage, LLMProvider, LLMResponse, LLMStreamEvent, MessageBus, SearchConfig, Session, SessionManager, SessionMessage, SessionRequestDispatcher, SessionRequestManager, SessionRequestRecord, SessionSearchManager, SkillInfo, SkillInfo as SkillInfo$1, SkillScope, ThinkingLevel, Tool, buildCompressingCompactionCheckpoint } from "@nextclaw/core";
 import { EventBus, Ingress, Unsubscribe } from "@nextclaw/shared";
-import { LocalAssetStore } from "@nextclaw/ncp-agent-runtime";
 import * as _$_nextclaw_ncp0 from "@nextclaw/ncp";
-import { ListMessagesOptions, ListSessionsOptions, NcpAgentClientEndpoint, NcpAgentRunApi, NcpAgentRunInput, NcpAgentRuntime, NcpContextBuilder, NcpContextPrepareOptions, NcpEndpointEvent, NcpLLMApi, NcpLLMApiInput, NcpLLMApiOptions, NcpMessage, NcpMessagePart, NcpSessionApi, NcpSessionPatch, NcpSessionStatus, NcpSessionSummary, NcpTool, NcpToolDefinition, NcpToolRegistry, OpenAIChatChunk } from "@nextclaw/ncp";
-import { AgentSessionStore, ChatTarget, DefaultNcpAgentBackend, NcpReplyInput, RuntimeFactoryParams } from "@nextclaw/ncp-toolkit";
-import { McpNcpToolRegistryAdapter } from "@nextclaw/ncp-mcp";
+import { ListMessagesOptions, ListSessionsOptions, NcpAgentConversationStateManager, NcpAgentRunInput, NcpAgentRunSendOptions, NcpAgentRunStreamOptions, NcpAgentRuntime, NcpContextBuilder, NcpContextPrepareOptions, NcpEndpointEvent, NcpLLMApi, NcpLLMApiInput, NcpLLMApiOptions, NcpMessage, NcpMessagePart, NcpRequestEnvelope, NcpSessionApi, NcpSessionPatch, NcpSessionStatus, NcpSessionSummary, NcpStreamRequestPayload, NcpTool, NcpToolRegistry, OpenAIChatChunk } from "@nextclaw/ncp";
 import { PluginChannelBinding, PluginRegistry, PluginUiMetadata } from "@nextclaw/openclaw-compat";
-import { NcpHttpAgentStreamProvider } from "@nextclaw/ncp-http-agent-server";
+import { AgentSessionStore, ChatTarget, EventPublisher, NcpReplyInput, RuntimeFactoryParams } from "@nextclaw/ncp-toolkit";
+import { LocalAssetStore } from "@nextclaw/ncp-agent-runtime";
 
 //#region src/types/entity-ids.types.d.ts
 type AgentId = string;
@@ -42,110 +39,75 @@ declare class AgentManager {
   detachTool: (agentId: AgentId, toolId: ToolId) => never;
 }
 //#endregion
-//#region src/managers/llm-provider.manager.d.ts
-type ProviderChatParams = {
-  messages: Array<Record<string, unknown>>;
-  tools?: Array<Record<string, unknown>>;
-  model?: string | null;
-  maxTokens?: number;
-  thinkingLevel?: ThinkingLevel | null;
-  signal?: AbortSignal;
+//#region src/managers/tool.manager.d.ts
+type UpdateToolCallResult = (params: {
+  sessionId: string;
+  toolCallId: string;
+  result: unknown;
+}) => Promise<void>;
+type ToolRunContext = {
+  agentId: string;
+  channel: string;
+  chatId: string;
+  config: Config;
+  execTimeoutSeconds: number;
+  handoffDepth: number;
+  metadata: Record<string, unknown>;
+  restrictToWorkspace: boolean;
+  searchConfig: SearchConfig;
+  sessionId: string;
+  workspace: string;
 };
-type LlmProviderRuntime = {
-  get: (model?: string | null) => LLMProvider;
-  chat: (params: ProviderChatParams) => Promise<LLMResponse>;
-  chatStream: (params: ProviderChatParams) => AsyncGenerator<LLMStreamEvent>;
+type ToolRegistrationContext = {
+  registerTool: (tool: Tool) => void;
+  registerNcpTool: (tool: NcpTool) => void;
+  hasTool: (name: string) => boolean;
+  getExtensionToolRunContext: () => ExtensionToolContext;
 };
-type ProviderConnectionTestInput = {
-  providerName: string | null;
-  apiKey?: string | null;
-  apiBase?: string | null;
-  defaultModel: string;
-  extraHeaders?: Record<string, string> | null;
-  wireApi?: "auto" | "chat" | "responses" | null;
-  messages: Array<Record<string, unknown>>;
-  maxTokens?: number;
-  signal?: AbortSignal;
+type ToolProvider = {
+  id: string;
+  registerTools: (context: ToolRunContext, registry: ToolRegistrationContext) => void;
 };
-declare class LlmProviderManager {
-  private readonly providerRegistry;
-  private readonly providerPool;
-  private readonly missingProvider;
-  private config;
-  constructor();
-  load: (config: Config) => void;
-  get: (model?: string | null) => LLMProvider;
-  readonly chat: (params: ProviderChatParams) => Promise<LLMResponse>;
-  readonly chatStream: (this: LlmProviderManager, params: ProviderChatParams) => AsyncGenerator<LLMStreamEvent>;
-  readonly testConnection: (input: ProviderConnectionTestInput) => Promise<void>;
-  private resolveRoute;
-  private resolveProvider;
-  private matchPrefixedProvider;
-  private getOrCreateProvider;
-  private createProvider;
-  private buildCacheKey;
+type ToolRuntimeRegistryOptions = {
+  updateToolCallResult: UpdateToolCallResult;
+};
+type ToolRuntimeRegistry = NcpToolRegistry & {
+  prepareForRun: (context: ToolRunContext) => void;
+};
+declare class ToolManager {
+  private readonly providers;
+  provideTools: (provider: ToolProvider) => {
+    dispose: () => void;
+  };
+  createRuntimeRegistry: (options: ToolRuntimeRegistryOptions) => ToolRuntimeRegistry;
 }
+declare function resolveAgentHandoffDepth(metadata: Record<string, unknown>): number;
 //#endregion
-//#region src/managers/extension.manager.d.ts
-type AgentRuntimeContribution = {
-  pluginId: string;
-  kind: string;
-  label: string;
-  createRuntime: (params: RuntimeFactoryParams) => NcpAgentRuntime;
-  createRuntimeForEntry?: (params: {
-    entry: {
-      id: string;
-      label: string;
-      type: string;
-      enabled?: boolean;
-      config?: Record<string, unknown>;
-    };
-    runtimeParams: RuntimeFactoryParams;
-  }) => NcpAgentRuntime;
-  describeSessionType?: (params?: {
-    describeMode?: "observation" | "probe";
-  }) => Promise<Record<string, unknown> | null | undefined> | Record<string, unknown> | null | undefined;
-  describeSessionTypeForEntry?: (params: {
-    entry: {
-      id: string;
-      label: string;
-      type: string;
-      enabled?: boolean;
-      config?: Record<string, unknown>;
-    };
-    describeParams?: {
-      describeMode?: "observation" | "probe";
-    };
-  }) => Promise<Record<string, unknown> | null | undefined> | Record<string, unknown> | null | undefined;
-  source?: string;
+//#region src/utils/session-run.utils.d.ts
+type LiveSessionExecution = {
+  runId: string;
+  controller: AbortController;
+  requestEnvelope: MaterializedAgentRunRequest;
+  abortHandled: boolean;
+  closed: boolean;
 };
-type NextclawExtensionRegistry = ExtensionRegistry & {
-  ncpAgentRuntimes: AgentRuntimeContribution[];
+type MaterializedAgentRunRequest = NcpRequestEnvelope & {
+  runId: string;
 };
-type ExtensionContributions = {
-  registry: PluginRegistry;
-  extensionRegistry: NextclawExtensionRegistry;
-  channelBindings?: PluginChannelBinding[];
-  uiMetadata?: PluginUiMetadata[];
+type LiveSession = {
+  sessionId: string;
+  agentId?: string;
+  createdAt: string;
+  stateManager: NcpAgentConversationStateManager;
+  metadata: Record<string, unknown>;
+  runtime: NcpAgentRuntime;
+  publisher: EventPublisher;
+  activeExecution: LiveSessionExecution | null;
+};
+type PublishSessionEventOptions = {
+  dispatchToStateManager?: boolean;
+  persistSession?: boolean;
 };
-declare class ExtensionManager {
-  private pluginRegistry;
-  private extensionRegistry;
-  private channelBindings;
-  private uiMetadata;
-  loadContributions: (contributions: ExtensionContributions) => void;
-  loadExtensionRegistry: (extensionRegistry: NextclawExtensionRegistry) => void;
-  getExtensionRegistry: () => NextclawExtensionRegistry;
-  getChannelBindings: () => PluginChannelBinding[];
-  getUiMetadata: () => PluginUiMetadata[];
-  toConfigView: (config: Config) => Config;
-  mergeConfigView: (current: Config, nextConfigView: Record<string, unknown>) => Config;
-  resolveMessageToolHints: (params: {
-    channel?: string | null;
-    config?: Config;
-    accountId?: string | null;
-  }) => string[];
-}
 //#endregion
 //#region src/features/runtime-registry/services/agent-runtime-registry.service.d.ts
 declare const DEFAULT_AGENT_RUNTIME_ENTRY_ID = "native";
@@ -218,7 +180,6 @@ type AgentRuntimeResolverConfig = {
 };
 declare function resolveAgentRuntimeEntries(params: {
   config: AgentRuntimeResolverConfig;
-  providerKinds: string[];
 }): {
   defaultEntryId: string;
   entries: AgentRuntimeEntry[];
@@ -232,7 +193,6 @@ declare class AgentRuntimeRegistry {
     entries: AgentRuntimeEntry[];
     defaultEntryId?: string;
   }) => void;
-  listProviderKinds: () => string[];
   createRuntime: (params: RuntimeFactoryParams) => NcpAgentRuntime;
   listSessionTypes: (params?: AgentRuntimeSessionTypeDescribeParams) => Promise<{
     defaultType: string;
@@ -240,273 +200,86 @@ declare class AgentRuntimeRegistry {
   }>;
 }
 //#endregion
-//#region src/features/runtime-registry/controllers/plugin-runtime-registration.controller.d.ts
-declare class PluginRuntimeRegistrationController {
-  private readonly runtimeRegistry;
-  private readonly extensions;
-  private readonly pluginRuntimeScopes;
-  private pluginRuntimeSnapshotKey;
-  constructor(runtimeRegistry: AgentRuntimeRegistry, extensions: ExtensionManager);
-  refreshPluginRuntimeRegistrations: () => void;
-  dispose: () => void;
-  private syncPluginRuntimeRegistrations;
-  private resolveActiveExtensionRegistry;
-}
-//#endregion
-//#region src/features/ncp-dispatch/utils/agent-runtime-handle.utils.d.ts
-type AgentRuntimeSessionTypes = Awaited<ReturnType<AgentRuntimeRegistry["listSessionTypes"]>>;
-type AgentRuntimeEndpoint = {
-  agentClientEndpoint: NcpAgentClientEndpoint;
-  streamProvider?: NcpHttpAgentStreamProvider;
-  listSessionTypes?: (params?: AgentRuntimeSessionTypeDescribeParams) => Promise<AgentRuntimeSessionTypes> | AgentRuntimeSessionTypes;
-  assetApi?: {
-    put: (input: {
-      fileName: string;
-      mimeType?: string | null;
-      bytes: Uint8Array;
-      createdAt?: Date;
-    }) => ReturnType<LocalAssetStore["putBytes"]>;
-    stat: LocalAssetStore["statRecord"];
-    resolveContentPath: LocalAssetStore["resolveContentPath"];
-  };
-  basePath?: string;
-};
-type AgentRuntimeHandle = AgentRuntimeEndpoint & {
-  runApi: NcpAgentRunApi;
-  sessionApi: NcpSessionApi;
-  applyMcpConfig?: (config: Config) => Promise<void>;
-  dispose?: () => Promise<void>;
-};
-declare function createAgentRuntimeHandle(params: {
-  backend: DefaultNcpAgentBackend;
-  agentClientEndpoint?: NcpAgentClientEndpoint;
-  runtimeRegistry: AgentRuntimeRegistry;
-  refreshPluginRuntimeRegistrations: () => void;
-  refreshConfiguredRuntimeEntries: () => void;
-  applyMcpConfig: (config: Config) => Promise<void>;
-  dispose: () => Promise<void>;
-  assetStore: LocalAssetStore;
-}): AgentRuntimeHandle;
-//#endregion
-//#region src/features/ncp-dispatch/utils/nextclaw-ncp-runner.utils.d.ts
-type AssetApi = {
-  put: (input: {
-    fileName: string;
-    mimeType?: string | null;
-    bytes: Uint8Array;
-    createdAt?: Date;
-  }) => Promise<{
-    uri: string;
-  }>;
-  resolveContentPath?: (uri: string) => string | null;
-};
-type NcpRunnerAgent = {
-  runApi: NcpAgentRunApi;
-  assetApi?: AssetApi;
-};
-type RunPromptOverNcpParams = {
-  agent: NcpRunnerAgent;
-  sessionId: string;
-  content: string;
-  attachments?: InboundAttachment[];
-  metadata?: Record<string, unknown>;
-  abortSignal?: AbortSignal;
-  onAssistantDelta?: (delta: string) => void;
-  onEvent?: (event: NcpEndpointEvent) => void;
-  missingCompletedMessageError?: string;
-  runErrorMessage?: string;
-};
-type StreamPromptOverNcpParams = Omit<RunPromptOverNcpParams, "onAssistantDelta" | "missingCompletedMessageError" | "runErrorMessage">;
-declare function buildUserMessageParts(params: {
-  content: string;
-  attachments?: InboundAttachment[];
-  assetApi?: AssetApi;
-}): Promise<NcpMessagePart[]>;
-declare function buildNcpUserMessage(params: {
-  sessionId: string;
-  content: string;
-  attachments?: InboundAttachment[];
-  metadata?: Record<string, unknown>;
-  assetApi?: AssetApi;
-}): Promise<NcpMessage>;
-declare function streamPromptOverNcp(params: StreamPromptOverNcpParams): AsyncGenerator<NcpEndpointEvent>;
-declare function runPromptOverNcp(params: RunPromptOverNcpParams): Promise<{
-  text: string;
-  completedMessage: NcpMessage;
-}>;
-//#endregion
-//#region src/features/ncp-dispatch/utils/channel-reply.utils.d.ts
-type ReplyCapableChannel = BaseChannel<Record<string, unknown>> & {
-  consumeNcpReply(input: NcpReplyInput): Promise<void>;
-};
-type ChannelReplyRoute = {
-  target: ChatTarget;
-  channel: ReplyCapableChannel;
-};
-type ResolvedInboundRoute = {
-  accountId?: string | null;
-};
-type ChannelReplyRouterDispatchParams = {
-  agent: NcpRunnerAgent;
-  route: ChannelReplyRoute;
-  sessionId: string;
-  content: string;
-  attachments?: InboundAttachment[];
-  metadata?: Record<string, unknown>;
-  abortSignal?: AbortSignal;
-  onEvent?: (event: NcpEndpointEvent) => void;
-};
-declare function isReplyCapableChannel(channel: BaseChannel<Record<string, unknown>> | null | undefined): channel is ReplyCapableChannel;
-declare function resolveChannelReplyRoute(params: {
-  channel: BaseChannel<Record<string, unknown>> | null | undefined;
-  message: InboundMessage;
-  route: ResolvedInboundRoute;
-}): ChannelReplyRoute | null;
-declare function dispatchChannelReplyRoute(params: ChannelReplyRouterDispatchParams): Promise<void>;
-//#endregion
-//#region src/features/ncp-dispatch/utils/nextclaw-ncp-dispatch.utils.d.ts
-type DirectPromptDispatchParams = {
-  config: Config;
-  sessionManager: SessionManager;
-  resolveNcpAgent?: () => NcpRunnerAgent | null;
-  content: string;
-  sessionKey?: string;
-  channel?: string;
-  chatId?: string;
-  attachments?: InboundAttachment[];
-  metadata?: Record<string, unknown>;
-  agentId?: string;
-  abortSignal?: AbortSignal;
-  onAssistantDelta?: (delta: string) => void;
-};
-type GatewayInboundLoopRuntime = {
-  kernel: {
-    channels: ChannelManager$1;
-  };
-  messageBus: MessageBus;
-  sessionManager: SessionManager;
-  configManager: {
-    loadConfig: () => Config;
-  };
-  liveAgentRuntime: NcpRunnerAgent | null;
-  appEventBus?: EventBus;
-};
-declare function dispatchPromptOverNcp(params: DirectPromptDispatchParams): Promise<string>;
-declare function runGatewayInboundLoop(runtime: GatewayInboundLoopRuntime): Promise<void>;
-//#endregion
-//#region src/types/llm-usage.types.d.ts
-type LlmUsageSummary = {
-  promptTokens: number;
-  completionTokens: number;
-  totalTokens: number;
-  cachedTokens: number;
-  cacheHit: boolean;
-  cacheMetricKeys: string[];
-};
-type LlmUsageRecord = {
-  version: 1;
-  observedAt: string;
-  source: string;
-  model: string | null;
-  usage: Record<string, number>;
-  summary: LlmUsageSummary;
-};
-type LlmUsageSnapshot = LlmUsageRecord;
-declare function createLlmUsageRecord(params: {
-  observedAt?: string;
-  source: string;
-  model?: string | null;
-  usage: Record<string, number>;
-}): LlmUsageRecord;
-declare function sanitizeLlmUsage(usage: Record<string, number>): Record<string, number>;
-declare function hasLlmUsageTelemetry(usage: Record<string, number>): boolean;
-declare function buildLlmUsageSummary(usage: Record<string, number>): LlmUsageSummary;
-declare function normalizeLlmUsageModel(value: string | null | undefined): string | null;
-//#endregion
-//#region src/stores/llm-usage.store.d.ts
-type LlmUsageStoreOptions = {
-  snapshotPath?: string;
-  historyPath?: string;
-};
-declare class LlmUsageStore {
-  private readonly options;
-  constructor(options?: LlmUsageStoreOptions);
-  get snapshotPath(): string;
-  get historyPath(): string;
-  readSnapshot: () => LlmUsageRecord | null;
-  writeSnapshot: (snapshot: LlmUsageRecord) => void;
-  clearSnapshot: () => void;
-  listHistory: () => LlmUsageRecord[];
-  appendHistory: (record: LlmUsageRecord) => void;
-  clearHistory: () => void;
-}
-//#endregion
-//#region src/managers/llm-usage.manager.d.ts
-type LlmUsageManagerOptions = {
-  store?: LlmUsageStore;
-};
-declare class LlmUsageManager {
-  private readonly store;
-  constructor(options?: LlmUsageManagerOptions);
-  observeProviderManager: (providerManager: LlmProviderRuntime, source: string) => LlmProviderRuntime;
-  record: (params: {
-    observedAt?: string;
-    source: string;
-    model?: string | null;
-    usage: Record<string, number>;
-  }) => LlmUsageRecord | null;
-}
-//#endregion
 //#region src/managers/agent-runtime.manager.d.ts
 type AgentRuntimeManagerOptions = {
-  bus: MessageBus;
-  providerManager: LlmProviderRuntime;
-  sessions: SessionManager;
-  ingress: Ingress;
-  sessionRequests: SessionRequestManager;
-  sessionSearch: SessionSearchManager;
-  ncpAgentSessionStore: AgentSessionStore;
-  cronService?: CronService | null;
   configManager: {
     loadConfig: () => Config;
   };
-  extensions: ExtensionManager;
-  eventBus: EventBus;
-  handleNcpEvent: (event: NcpEndpointEvent) => void;
-  llmUsage: LlmUsageManager;
-  onSessionUpdated: (sessionKey: string) => void;
+  assetStore: LocalAssetStore;
 };
 declare class AgentRuntimeManager {
   private readonly params;
   private readonly runtimeRegistry;
-  private readonly mcpRuntimeSupport;
-  private readonly assetStore;
-  private readonly pluginRuntimeRegistrationController;
   private readonly refreshConfiguredRuntimeEntries;
-  private backend;
-  private handle;
-  private builtinNarpRegistrations;
-  private kernelBootstrapped;
-  private warmupPromise;
-  private unsubscribeNcpEvents;
-  private unsubscribeAgentRuntimeRequestIngress;
-  private gatewayController;
   private disposed;
   constructor(params: AgentRuntimeManagerOptions);
-  get currentHandle(): AgentRuntimeHandle | null;
-  isLiveSessionRunning: (sessionId: string) => boolean;
-  connectGatewayController: (gatewayController: GatewayController) => void;
-  bootstrap: () => Promise<AgentRuntimeHandle>;
-  private readonly materializeAgentSendEnvelope;
-  private readonly createMaterializingAgentClientEndpoint;
-  warmDerivedCapabilities: () => Promise<void>;
+  registerRuntimeProvider: (registration: AgentRuntimeProviderRegistration) => Disposable;
+  createRuntime: (runtimeParams: RuntimeFactoryParams) => _$_nextclaw_ncp0.NcpAgentRuntime;
+  listSessionTypes: (describeParams?: AgentRuntimeSessionTypeDescribeParams) => Promise<{
+    defaultType: string;
+    options: AgentRuntimeSessionTypeOption[];
+  }>;
+  dispose: () => Promise<void>;
+  private readonly assertNotDisposed;
+}
+//#endregion
+//#region src/managers/session-run.manager.d.ts
+declare class SessionRunManager {
+  private readonly agentRuntimeManager;
+  private readonly ncpAgentSessionStore;
+  private readonly eventBus;
+  private readonly onSessionUpdated;
+  private readonly liveSessions;
+  private readonly publisher;
+  private disposed;
+  constructor(options: {
+    agentRuntimeManager: AgentRuntimeManager;
+    ncpAgentSessionStore: AgentSessionStore;
+    eventBus: EventBus;
+    onSessionUpdated: (sessionKey: string) => void;
+  });
   dispose: () => Promise<void>;
-  private readonly registerCoreRuntimes;
-  private runDerivedCapabilityWarmup;
+  isRunning: (sessionId: string) => boolean;
+  getOrCreateLiveSession: (sessionId: string, initialMetadata?: Record<string, unknown>) => Promise<LiveSession>;
+  getActiveSessionRun: (sessionId: string) => LiveSessionExecution | null;
+  setActiveSessionRun: (sessionId: string, activeRun: LiveSessionExecution) => void;
+  deleteActiveSessionRun: (sessionId: string, runId: string) => void;
+  streamSessionEvents: (payload: NcpStreamRequestPayload, options?: NcpAgentRunStreamOptions) => AsyncIterable<NcpEndpointEvent>;
+  updateToolCallResult: UpdateToolCallResult;
+  appendSessionEvent: (sessionId: string, event: NcpEndpointEvent, options?: PublishSessionEventOptions) => Promise<void>;
+  private readonly ensureLiveSession;
+  private readonly requireLiveSession;
+  private readonly publishSessionEvent;
+  private readonly persistLiveSessionEvent;
+  private readonly assertNotDisposed;
   private publishSessionRunStatus;
-  private publishNcpEvent;
-  private handleSessionMessageRequest;
-  private updateToolCallResult;
+}
+//#endregion
+//#region src/managers/agent-run-request.manager.d.ts
+declare class AgentRunRequestManager {
+  private readonly cleanups;
+  private readonly sessions;
+  private readonly ingress;
+  private readonly sessionRunManager;
+  private readonly onSessionUpdated;
+  private disposed;
+  private started;
+  constructor(options: {
+    sessions: SessionManager;
+    ingress: Ingress;
+    sessionRunManager: SessionRunManager;
+    onSessionUpdated: (sessionKey: string) => void;
+  });
+  start: () => void;
+  dispose: () => Promise<void>;
+  run: (envelope: NcpRequestEnvelope, options?: NcpAgentRunSendOptions) => AsyncIterable<NcpEndpointEvent>;
+  private readonly handleSendRequest;
+  private readonly handleAbortRequest;
+  private readonly iterateRun;
+  private readonly materializeSendEnvelope;
+  private readonly toNcpSendEnvelope;
+  private readonly materializeRunEnvelope;
+  private readonly handleSessionMessageRequest;
   private readonly assertNotDisposed;
 }
 //#endregion
@@ -518,6 +291,50 @@ declare class AutomationManager extends CronService {
   constructor(options: AutomationManagerOptions);
 }
 //#endregion
+//#region src/managers/llm-provider.manager.d.ts
+type ProviderChatParams = {
+  messages: Array<Record<string, unknown>>;
+  tools?: Array<Record<string, unknown>>;
+  model?: string | null;
+  maxTokens?: number;
+  thinkingLevel?: ThinkingLevel | null;
+  signal?: AbortSignal;
+};
+type LlmProviderRuntime = {
+  get: (model?: string | null) => LLMProvider;
+  chat: (params: ProviderChatParams) => Promise<LLMResponse>;
+  chatStream: (params: ProviderChatParams) => AsyncGenerator<LLMStreamEvent>;
+};
+type ProviderConnectionTestInput = {
+  providerName: string | null;
+  apiKey?: string | null;
+  apiBase?: string | null;
+  defaultModel: string;
+  extraHeaders?: Record<string, string> | null;
+  wireApi?: "auto" | "chat" | "responses" | null;
+  messages: Array<Record<string, unknown>>;
+  maxTokens?: number;
+  signal?: AbortSignal;
+};
+declare class LlmProviderManager {
+  private readonly providerRegistry;
+  private readonly providerPool;
+  private readonly missingProvider;
+  private config;
+  constructor();
+  load: (config: Config) => void;
+  get: (model?: string | null) => LLMProvider;
+  readonly chat: (params: ProviderChatParams) => Promise<LLMResponse>;
+  readonly chatStream: (this: LlmProviderManager, params: ProviderChatParams) => AsyncGenerator<LLMStreamEvent>;
+  readonly testConnection: (input: ProviderConnectionTestInput) => Promise<void>;
+  private resolveRoute;
+  private resolveProvider;
+  private matchPrefixedProvider;
+  private getOrCreateProvider;
+  private createProvider;
+  private buildCacheKey;
+}
+//#endregion
 //#region src/managers/config.manager.d.ts
 type ConfigManagerRuntimeHooks = {
   resolveChannelConfig?: (config: Config) => Config;
@@ -546,6 +363,16 @@ type ConfigManagerOptions = {
   channels: ChannelManager$1;
   providerManager: LlmProviderManager;
 };
+type ConfigMutationResult = Record<string, unknown> & {
+  ok: boolean;
+  error?: string;
+};
+type RawConfigMutationParams = {
+  raw: string;
+  baseHash?: string;
+  note?: string;
+  version?: string;
+};
 declare class ConfigManager {
   private readonly options;
   readonly configPath: string;
@@ -562,6 +389,14 @@ declare class ConfigManager {
   installRuntimeHooks: (hooks: ConfigManagerRuntimeHooks) => void;
   applyLiveConfigReload: () => Promise<void>;
   applyReloadPlan: (nextConfig: Config) => Promise<void>;
+  getConfigSnapshot: (params?: {
+    version?: string;
+  }) => Record<string, unknown>;
+  getConfigSchema: (params?: {
+    version?: string;
+  }) => Record<string, unknown>;
+  applyRawConfig: (params: RawConfigMutationParams) => Promise<ConfigMutationResult>;
+  patchRawConfig: (params: RawConfigMutationParams) => Promise<ConfigMutationResult>;
   scheduleReload: (reason: string) => void;
   runReload: (reason: string) => Promise<void>;
   reloadConfig: (reason?: string) => Promise<string>;
@@ -574,86 +409,260 @@ declare class ConfigManager {
   private reloadPlugins;
   private reloadMcp;
   private reloadCompanion;
+  private readConfigSnapshot;
+  private redactConfig;
+  private validateBaseHash;
+  private validateConfigInput;
+  private mutateRawConfig;
+  private applyConfigChange;
+  private createConfigMutationResult;
+}
+//#endregion
+//#region src/services/extension-plugin-registry.service.d.ts
+type ExtensionPluginLoadProgress = {
+  loadedPluginCount: number;
+  pluginId?: string;
+};
+declare class ExtensionPluginRegistryService {
+  discoverEnabledPluginCount: (params: {
+    config: Config;
+    workspace: string;
+  }) => number;
+  load: (params: {
+    config: Config;
+    workspace: string;
+  }) => PluginRegistry;
+  loadProgressively: (params: {
+    config: Config;
+    workspace: string;
+    onPluginProcessed?: (params: ExtensionPluginLoadProgress) => void;
+  }) => Promise<PluginRegistry>;
+  private resolveLoadingContext;
+}
+//#endregion
+//#region src/managers/extension.manager.d.ts
+type ExtensionLoadProgress = ExtensionPluginLoadProgress;
+type ExtensionLoadResult = {
+  diagnostics: PluginRegistry["diagnostics"];
+  totalPluginCount: number;
+  loadedPluginCount: number;
+  shouldRestartChannels: boolean;
+};
+type ExtensionManagerOptions = {
+  configManager: Pick<ConfigManager, "loadConfig">;
+  eventBus: Pick<EventBus, "emitEnvelope">;
+  ingress: Pick<Ingress, "addHandler">;
+  messageBus: Pick<MessageBus, "publishInbound">;
+};
+type ExtensionLoadParams = {
+  config?: Config;
+  changedPaths?: readonly string[];
+  onLoadStart?: (params: {
+    totalPluginCount: number;
+  }) => void;
+  onPluginProcessed?: (params: ExtensionLoadProgress) => void;
+};
+declare class ExtensionManager {
+  private readonly options;
+  private snapshot;
+  private readonly runtime;
+  private readonly pluginRegistry;
+  constructor(options: ExtensionManagerOptions);
+  load: (params: ExtensionLoadParams) => Promise<ExtensionLoadResult>;
+  reloadForConfigChange: (params: ExtensionLoadParams & {
+    changedPaths: readonly string[];
+  }) => Promise<ExtensionLoadResult>;
+  registerIngressHandlers: () => void;
+  start: (params: {
+    endpoint: string | null;
+  }) => Promise<void>;
+  stop: () => Promise<void>;
+  getExtensionRegistry: () => ExtensionRegistry;
+  getChannelBindings: () => PluginChannelBinding[];
+  getUiMetadata: () => PluginUiMetadata[];
+  toConfigView: (config: Config) => Config;
+  mergeConfigView: (current: Config, nextConfigView: Record<string, unknown>) => Config;
+  private readonly getWorkspace;
 }
 //#endregion
-//#region src/configs/learning-loop.config.d.ts
-declare const LEARNING_LOOP_DISABLED_METADATA_KEY = "learning_loop_disabled";
-declare const LEARNING_LOOP_LAST_TOOL_CALL_COUNT_METADATA_KEY = "learning_loop_last_tool_call_count";
-declare const LEARNING_LOOP_LAST_REQUESTED_AT_METADATA_KEY = "learning_loop_last_requested_at";
-declare const LEARNING_LOOP_LAST_REVIEW_SESSION_ID_METADATA_KEY = "learning_loop_last_review_session_id";
-declare const LEARNING_LOOP_SOURCE_SESSION_ID_METADATA_KEY = "learning_loop_source_session_id";
-declare const LEARNING_LOOP_REQUESTED_SKILLS: string[];
-declare const DEFAULT_LEARNING_LOOP_TOOL_CALL_THRESHOLD = 15;
-type LearningLoopRuntimeConfig = {
-  enabled: boolean;
-  toolCallThreshold: number;
+//#region src/types/llm-usage.types.d.ts
+type LlmUsageSummary = {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+  cachedTokens: number;
+  cacheHit: boolean;
+  cacheMetricKeys: string[];
+};
+type LlmUsageRecord = {
+  version: 1;
+  observedAt: string;
+  source: string;
+  model: string | null;
+  usage: Record<string, number>;
+  summary: LlmUsageSummary;
+};
+type LlmUsageSnapshot = LlmUsageRecord;
+declare function createLlmUsageRecord(params: {
+  observedAt?: string;
+  source: string;
+  model?: string | null;
+  usage: Record<string, number>;
+}): LlmUsageRecord;
+declare function sanitizeLlmUsage(usage: Record<string, number>): Record<string, number>;
+declare function hasLlmUsageTelemetry(usage: Record<string, number>): boolean;
+declare function buildLlmUsageSummary(usage: Record<string, number>): LlmUsageSummary;
+declare function normalizeLlmUsageModel(value: string | null | undefined): string | null;
+//#endregion
+//#region src/stores/llm-usage.store.d.ts
+type LlmUsageStoreOptions = {
+  snapshotPath?: string;
+  historyPath?: string;
 };
-declare function readLearningLoopRuntimeConfig(config: Config): LearningLoopRuntimeConfig;
+declare class LlmUsageStore {
+  private readonly options;
+  constructor(options?: LlmUsageStoreOptions);
+  get snapshotPath(): string;
+  get historyPath(): string;
+  readSnapshot: () => LlmUsageRecord | null;
+  writeSnapshot: (snapshot: LlmUsageRecord) => void;
+  clearSnapshot: () => void;
+  listHistory: () => LlmUsageRecord[];
+  appendHistory: (record: LlmUsageRecord) => void;
+  clearHistory: () => void;
+}
 //#endregion
-//#region src/managers/learning-loop.manager.d.ts
-type LearningLoopSessionRequester = {
-  spawnSessionAndRequest: (params: SpawnSessionAndRequestParams) => Promise<SessionRequestToolResult>;
+//#region src/managers/llm-usage.manager.d.ts
+type LlmUsageStats = {
+  totalRecords: number;
+  usageRecordCount: number;
+  emptyUsageRecordCount: number;
+  promptTokenRecordCount: number;
+  oldestObservedAt: string | null;
+  latestObservedAt: string | null;
+  totalPromptTokens: number;
+  totalCompletionTokens: number;
+  totalTokens: number;
+  totalCachedTokens: number;
+  cacheHitRecords: number;
+  cacheHitRate: number;
+  tokenCacheRate: number;
+  sources: Array<{
+    value: string;
+    count: number;
+  }>;
+  models: Array<{
+    value: string;
+    count: number;
+  }>;
 };
-type LearningLoopManagerOptions = {
-  eventBus: EventBus;
-  sessionManager: SessionManager;
-  sessionRequester: LearningLoopSessionRequester;
-  resolveLearningLoopConfig?: () => LearningLoopRuntimeConfig;
+type LlmUsageManagerOptions = {
+  store?: LlmUsageStore;
 };
-declare class LearningLoopManager {
-  private readonly options;
-  private readonly sessionStore;
-  private readonly inFlightSessionIds;
-  private unsubscribe;
-  constructor(options: LearningLoopManagerOptions);
+declare class LlmUsageManager {
+  private readonly store;
+  constructor(options?: LlmUsageManagerOptions);
+  get snapshotPath(): string;
+  get historyPath(): string;
+  observeProviderManager: (providerManager: LlmProviderRuntime, source: string) => LlmProviderRuntime;
+  record: (params: {
+    observedAt?: string;
+    source: string;
+    model?: string | null;
+    usage: Record<string, number>;
+  }) => LlmUsageRecord | null;
+  getSnapshot: () => LlmUsageRecord | null;
+  getHistory: (limit?: string | number) => LlmUsageRecord[];
+  resolveHistoryLimit: (value?: string | number) => number;
+  getStats: () => LlmUsageStats;
+  private readonly bumpCounter;
+  private readonly toSortedCounts;
+}
+//#endregion
+//#region src/managers/mcp.manager.d.ts
+declare class McpManager {
+  private currentMcpConfig;
+  private readonly mcpLifecycleManager;
+  private readonly mcpRegistryService;
+  private readonly toolRegistryAdapter;
+  private warmupPromise;
+  constructor(getConfig: () => Config);
+  listToolsForRun: (params: {
+    agentId: string;
+  }) => ReadonlyArray<NcpTool>;
   start: () => void;
-  dispose: () => void;
-  private handleRunFinished;
-  private handleRunFinishedInBackground;
-  private readRuntimeConfig;
-  private buildReviewTitle;
+  applyConfig: (config: Config) => Promise<void>;
+  dispose: () => Promise<void>;
+  private prewarmEnabledServersSafely;
 }
 //#endregion
-//#region src/types/skill.types.d.ts
-type SkillRecord = {
-  id: SkillId;
-  name: string;
-  description: string;
-  toolIds: ToolId[];
-  enabled: boolean;
-  metadata: Record<string, unknown>;
+//#region src/utils/skill-frontmatter.utils.d.ts
+type LocalizedTextMap = Record<string, string>;
+type SkillFrontmatter = {
+  name?: string;
+  summary?: string;
+  summaryI18n?: LocalizedTextMap;
+  description?: string;
+  descriptionI18n?: LocalizedTextMap;
+  author?: string;
+  tags?: string[];
 };
+declare function parseSkillFrontmatter(raw: string): SkillFrontmatter;
+declare function stripSkillFrontmatter(raw: string): string;
+declare function buildLocalizedTextMap(englishText: string, ...maps: Array<LocalizedTextMap | Partial<LocalizedTextMap> | undefined>): LocalizedTextMap;
 //#endregion
 //#region src/managers/skill.manager.d.ts
-declare class SkillManager {
-  listSkills: () => never;
-  getSkill: (skillId: SkillId) => never;
-  requireSkill: (skillId: SkillId) => never;
-  saveSkill: (skill: SkillRecord) => never;
-  enableSkill: (skillId: SkillId) => never;
-  disableSkill: (skillId: SkillId) => never;
-  resolveSkills: (skillIds: SkillId[]) => never;
-}
-//#endregion
-//#region src/types/tool.types.d.ts
-type ToolRecord = {
-  id: ToolId;
+type WorkspaceParams = {
+  workspace: string;
+};
+type InstalledSkillSummary = {
+  ref: string;
   name: string;
-  description: string;
-  inputSchema?: Record<string, unknown>;
-  enabled: boolean;
-  metadata: Record<string, unknown>;
+  path: string;
+  relativePath: string | null;
+  scope: SkillInfo$1["scope"];
+  source: SkillInfo$1["source"];
+  summary: string | null;
+  summaryI18n: LocalizedTextMap | null;
+  description: string | null;
+  descriptionI18n: LocalizedTextMap | null;
+  author: string | null;
+  tags: string[];
+  always: boolean;
 };
-//#endregion
-//#region src/managers/tool.manager.d.ts
-declare class ToolManager {
-  listTools: () => never;
-  getTool: (toolId: ToolId) => never;
-  requireTool: (toolId: ToolId) => never;
-  saveTool: (tool: ToolRecord) => never;
-  enableTool: (toolId: ToolId) => never;
-  disableTool: (toolId: ToolId) => never;
-  resolveTools: (toolIds: ToolId[]) => never;
+type InstalledSkillDetail = InstalledSkillSummary & {
+  metadata: Record<string, string> | null;
+  raw: string;
+  bodyRaw: string;
+};
+type InstalledSkillsList = {
+  workspace: string;
+  total: number;
+  skills: InstalledSkillSummary[];
+};
+declare class SkillManager {
+  private readonly loader;
+  private readonly workspace;
+  constructor(params: WorkspaceParams);
+  listSkills: (params?: {
+    filterUnavailable?: boolean;
+  }) => SkillInfo$1[];
+  getSkillInfo: (selector: string) => SkillInfo$1 | null;
+  getSkillMetadata: (selector: string | SkillInfo$1) => Record<string, string> | null;
+  loadSkillContent: (selector: string) => string | null;
+  listInstalledSkills: (params?: {
+    query?: string;
+    scope?: string;
+  }) => InstalledSkillsList;
+  getInstalledSkillDetail: (selector: string) => InstalledSkillDetail | null;
+  findBuiltinSkill: (name: string) => SkillInfo$1 | null;
+  resolveBuiltinSkillDir: (name: string) => string | null;
+  private buildInstalledSkillSummary;
+  private matchesInstalledSkillQuery;
+  private readAlwaysFlag;
+  private buildRelativePath;
+  private normalizeInstalledScope;
+  private normalizeOptionalString;
 }
 //#endregion
 //#region src/services/ncp-session-api.service.d.ts
@@ -665,7 +674,7 @@ type NcpSessionApiServiceOptions = {
   eventBus: EventBus;
   getConfig: () => Config;
   isLiveSessionRunning?: (sessionId: string) => boolean;
-  ncpAgentSessionStore?: NcpAgentSessionReadableStore;
+  ncpAgentSessionStore: NcpAgentSessionReadableStore;
   sessionManager: SessionManager;
 };
 declare class NcpSessionApiService implements NcpSessionApi {
@@ -681,6 +690,7 @@ declare class NcpSessionApiService implements NcpSessionApi {
   getSession: (sessionId: string) => Promise<NcpSessionSummary | null>;
   updateSession: (sessionId: string, patch: NcpSessionPatch) => Promise<NcpSessionSummary | null>;
   deleteSession: (sessionId: string) => Promise<void>;
+  private createSummaryFromRecord;
   private withLiveSessionStatus;
 }
 //#endregion
@@ -712,47 +722,166 @@ declare class NextclawKernel {
   readonly agents: AgentManager;
   readonly sessions: SessionManager;
   readonly control: NextclawKernelControlManager<unknown, unknown, unknown>;
-  readonly tools: ToolManager;
+  readonly toolManager: ToolManager;
   readonly skills: SkillManager;
   readonly automation: AutomationManager;
   readonly channels: ChannelManager$1;
   readonly sessionRequests: SessionRequestManager;
   readonly sessionSearch: SessionSearchManager;
+  readonly assetStore: LocalAssetStore;
+  readonly mcpManager: McpManager;
   readonly ncpSessionApi: NcpSessionApiService;
   readonly extensions: ExtensionManager;
+  readonly agentRunRequestManager: AgentRunRequestManager;
+  readonly sessionRunManager: SessionRunManager;
   readonly agentRuntimeManager: AgentRuntimeManager;
-  readonly learningLoop: LearningLoopManager;
-  private readonly sessionLifecycleEvents;
   private readonly ncpAgentSessionStore;
   private readonly ncpAgentSessionJournalStore;
   private readonly contributions;
+  private gatewayController;
   constructor(options?: NextclawKernelOptions);
+  provideGatewayController: (gatewayController: GatewayController) => void;
+  getGatewayController: () => GatewayController | undefined;
   start: () => Promise<void>;
   dispose: () => Promise<void>;
-  private publishSessionUpdated;
-  private handleNcpEvent;
+  publishSessionUpdated: (sessionKey: string) => void;
 }
 //#endregion
-//#region src/utils/learning-loop-prompt.utils.d.ts
-declare function buildLearningLoopTask(params: {
-  sessionId: string;
-  toolCallsSinceReview: number;
-  currentToolCallCount: number;
-}): string;
+//#region src/contributions/learning-loop/config.d.ts
+type LearningLoopRuntimeConfig = {
+  enabled: boolean;
+  toolCallThreshold: number;
+};
+declare function readLearningLoopRuntimeConfig(config: Config): LearningLoopRuntimeConfig;
 //#endregion
-//#region src/features/narp-runtime/services/builtin-narp-runtime-registration.service.d.ts
+//#region src/features/narp-runtime/services/builtin-narp-runtime-provider.service.d.ts
 declare const NARP_HTTP_RUNTIME_KIND = "narp-http";
 declare const NARP_STDIO_RUNTIME_KIND = "narp-stdio";
-declare class BuiltinNarpRuntimeRegistrationService {
+declare class BuiltinNarpRuntimeProviderService {
   private readonly getConfig;
   constructor(getConfig: () => Config);
-  registerInto: (runtimeRegistry: AgentRuntimeRegistry) => Disposable[];
+  createProviders: () => AgentRuntimeProviderRegistration[];
   private createUnavailableRuntime;
   private createHttpRuntime;
   private createStdioRuntime;
 }
 //#endregion
-//#region src/features/native-runtime/services/context-compaction-preflight.service.d.ts
+//#region src/features/ncp-dispatch/utils/nextclaw-ncp-runner.utils.d.ts
+type AssetApi = {
+  put: (input: {
+    fileName: string;
+    mimeType?: string | null;
+    bytes: Uint8Array;
+    createdAt?: Date;
+  }) => Promise<{
+    uri: string;
+  }>;
+  resolveContentPath?: (uri: string) => string | null;
+};
+type NcpRunnerAgent = {
+  run: (envelope: NcpRequestEnvelope, options?: NcpAgentRunSendOptions) => AsyncIterable<NcpEndpointEvent>;
+  assetApi?: AssetApi;
+};
+type RunPromptOverNcpParams = {
+  agent: NcpRunnerAgent;
+  sessionId: string;
+  content: string;
+  attachments?: InboundAttachment[];
+  metadata?: Record<string, unknown>;
+  abortSignal?: AbortSignal;
+  onAssistantDelta?: (delta: string) => void;
+  onEvent?: (event: NcpEndpointEvent) => void;
+  missingCompletedMessageError?: string;
+  runErrorMessage?: string;
+};
+type StreamPromptOverNcpParams = Omit<RunPromptOverNcpParams, "onAssistantDelta" | "missingCompletedMessageError" | "runErrorMessage">;
+declare function buildUserMessageParts(params: {
+  content: string;
+  attachments?: InboundAttachment[];
+  assetApi?: AssetApi;
+}): Promise<NcpMessagePart[]>;
+declare function buildNcpUserMessage(params: {
+  sessionId: string;
+  content: string;
+  attachments?: InboundAttachment[];
+  metadata?: Record<string, unknown>;
+  assetApi?: AssetApi;
+}): Promise<NcpMessage>;
+declare function streamPromptOverNcp(params: StreamPromptOverNcpParams): AsyncGenerator<NcpEndpointEvent>;
+declare function runPromptOverNcp(params: RunPromptOverNcpParams): Promise<{
+  text: string;
+  completedMessage: NcpMessage;
+}>;
+//#endregion
+//#region src/features/ncp-dispatch/services/gateway-inbound-processor.service.d.ts
+type GatewayInboundLoopRuntime = {
+  kernel: {
+    channels: ChannelManager$1;
+    agentRunRequestManager: NcpRunnerAgent;
+  };
+  messageBus: MessageBus;
+  configManager: {
+    loadConfig: () => Config;
+  };
+  appEventBus?: EventBus;
+};
+declare class GatewayInboundProcessor {
+  private runtime;
+  constructor(runtime: GatewayInboundLoopRuntime);
+  process: (message: InboundMessage) => Promise<void>;
+  private resolveRoute;
+  private dispatchChannelReplyRouteMaybe;
+  private publishLegacyReply;
+}
+declare function runGatewayInboundLoop(runtime: GatewayInboundLoopRuntime): Promise<void>;
+//#endregion
+//#region src/features/ncp-dispatch/utils/channel-reply.utils.d.ts
+type ReplyCapableChannel = BaseChannel<Record<string, unknown>> & {
+  consumeNcpReply(input: NcpReplyInput): Promise<void>;
+};
+type ChannelReplyRoute = {
+  target: ChatTarget;
+  channel: ReplyCapableChannel;
+};
+type ResolvedInboundRoute = {
+  accountId?: string | null;
+};
+type ChannelReplyRouterDispatchParams = {
+  agent: NcpRunnerAgent;
+  route: ChannelReplyRoute;
+  sessionId: string;
+  content: string;
+  attachments?: InboundAttachment[];
+  metadata?: Record<string, unknown>;
+  abortSignal?: AbortSignal;
+  onEvent?: (event: NcpEndpointEvent) => void;
+};
+declare function isReplyCapableChannel(channel: BaseChannel<Record<string, unknown>> | null | undefined): channel is ReplyCapableChannel;
+declare function resolveChannelReplyRoute(params: {
+  channel: BaseChannel<Record<string, unknown>> | null | undefined;
+  message: InboundMessage;
+  route: ResolvedInboundRoute;
+}): ChannelReplyRoute | null;
+declare function dispatchChannelReplyRoute(params: ChannelReplyRouterDispatchParams): Promise<void>;
+//#endregion
+//#region src/features/ncp-dispatch/utils/nextclaw-ncp-dispatch.utils.d.ts
+type DirectPromptDispatchParams = {
+  config: Config;
+  sessionManager: SessionManager;
+  agentRunRequests: NcpRunnerAgent;
+  content: string;
+  sessionKey?: string;
+  channel?: string;
+  chatId?: string;
+  attachments?: InboundAttachment[];
+  metadata?: Record<string, unknown>;
+  agentId?: string;
+  abortSignal?: AbortSignal;
+  onAssistantDelta?: (delta: string) => void;
+};
+declare function dispatchPromptOverNcp(params: DirectPromptDispatchParams): Promise<string>;
+//#endregion
+//#region src/features/context-compaction/services/context-compaction-preflight.service.d.ts
 type ContextWindowOwner = "nextclaw" | "runtime";
 type ContextCompactionPreflightResult = {
   contextWindow: ContextWindowSnapshot;
@@ -806,109 +935,67 @@ declare class ContextCompactionPreflightService {
   private generateSummary;
 }
 //#endregion
+//#region src/features/context-compaction/utils/context-compaction-projection.utils.d.ts
+declare function projectNcpMessagesWithContextCompaction(params: {
+  sessionId: string;
+  sessionMessages: readonly NcpMessage[];
+}): NcpMessage[];
+//#endregion
+//#region src/features/context-compaction/utils/context-compaction-timeline-message.utils.d.ts
+declare const NEXTCLAW_TIMELINE_KIND_METADATA_KEY = "nextclaw_timeline_kind";
+declare const CONTEXT_COMPACTION_TIMELINE_KIND = "context_compaction";
+type ContextCompactionTimelineCheckpoint = {
+  version: 1;
+  id: string;
+  status: "compressing" | "compressed";
+  summary: string;
+  coveredMessageCount: number;
+  coveredSessionMessageCount: number;
+  originalEstimatedTokens: number;
+  projectedEstimatedTokens: number;
+  createdAt: string;
+  updatedAt: string;
+};
+declare function buildContextCompactionTimelineNcpMessage(params: {
+  sessionId: string;
+  checkpoint: ContextCompactionTimelineCheckpoint;
+}): NcpMessage;
+declare function upsertContextCompactionTimelineMessage(params: {
+  session: Session;
+  checkpoint: ContextCompactionTimelineCheckpoint;
+  insertBeforeMessageIds?: readonly string[];
+}): void;
+declare function isContextCompactionTimelineMessage(message: {
+  metadata?: Record<string, unknown> | undefined;
+} | null | undefined): boolean;
+//#endregion
 //#region src/features/native-runtime/services/native-agent-runtime-factory.service.d.ts
 type NativeRuntimeFactory = (runtimeParams: RuntimeFactoryParams) => NcpAgentRuntime;
-type UpdateToolCallResult = (params: {
-  sessionId: string;
-  toolCallId: string;
-  result: unknown;
-}) => Promise<void>;
 type NativeAgentRuntimeFactoryOptions = {
-  bus: MessageBus;
   providerManager: LlmProviderRuntime;
   sessions: SessionManager;
-  sessionRequests: SessionRequestManager;
-  sessionSearch: SessionSearchManager;
-  cronService?: CronService | null;
   configManager: {
     loadConfig: () => Config;
   };
-  extensions: ExtensionManager;
   llmUsage: LlmUsageManager;
   onSessionUpdated: (sessionKey: string) => void;
-  resolveGatewayController: () => GatewayController | undefined;
-  mcpToolRegistryAdapter: McpNcpToolRegistryAdapter;
   assetStore: LocalAssetStore;
   updateToolCallResult: UpdateToolCallResult;
+  toolManager: ToolManager;
 };
 declare class NativeAgentRuntimeFactory {
   private readonly options;
   private readonly observedProviderManager;
   constructor(options: NativeAgentRuntimeFactoryOptions);
   create: NativeRuntimeFactory;
-  resolveOpenAiToolsForRuntime: (input: NcpAgentRunInput) => _$_nextclaw_ncp0.OpenAITool[] | undefined;
   private createToolRegistry;
 }
 //#endregion
-//#region src/features/native-runtime/services/nextclaw-ncp-tool-registry.service.d.ts
-type NextclawNcpToolRegistryOptions = {
-  bus: MessageBus;
-  providerManager: LlmProviderRuntime;
-  sessionManager: SessionManager;
-  cronService?: CronService | null;
-  gatewayController?: GatewayController;
-  getConfig: () => Config;
-  getExtensionRegistry?: () => ExtensionRegistry | undefined;
-  getAdditionalTools?: (context: PreparedRunContext) => ReadonlyArray<NcpTool>;
-  onSessionUpdated?: (sessionKey: string) => void;
-  sessionRequestManager: SessionRequestManager;
-  updateToolCallResult: (params: {
-    sessionId: string;
-    toolCallId: string;
-    result: unknown;
-  }) => Promise<void>;
-};
-type PreparedRunContext = {
-  agentId: string;
-  channel: string;
-  chatId: string;
-  config: Config;
-  contextTokens: number;
-  execTimeoutSeconds: number;
-  handoffDepth: number;
-  maxTokens?: number;
-  metadata: Record<string, unknown>;
-  model: string;
-  restrictToWorkspace: boolean;
-  searchConfig: SearchConfig;
-  sessionId: string;
-  workspace: string;
-};
-declare class NextclawNcpToolRegistry implements NcpToolRegistry {
-  private readonly options;
-  private registry;
-  private readonly tools;
-  private currentExtensionToolContext;
-  constructor(options: NextclawNcpToolRegistryOptions);
-  prepareForRun: (context: PreparedRunContext) => void;
-  listTools: () => ReadonlyArray<NcpTool>;
-  getTool: (name: string) => NcpTool | undefined;
-  getToolDefinitions: () => ReadonlyArray<NcpToolDefinition>;
-  execute: (toolCallId: string, toolName: string, args: unknown) => Promise<unknown>;
-  private buildToolExecutionContext;
-  private registerDefaultTools;
-  private registerMessagingTools;
-  private resolveMessageChannels;
-  private registerExtensionTools;
-  private registerTool;
-  private registerAdditionalTools;
-  private isToolAvailable;
-}
-declare function resolveAgentHandoffDepth(metadata: Record<string, unknown>): number;
-declare function readAccountIdForHints(metadata: Record<string, unknown>, sessionMetadata: Record<string, unknown>): string | undefined;
-//#endregion
 //#region src/features/native-runtime/services/nextclaw-ncp-context-builder.service.d.ts
-type MessageToolHintsResolver = (params: {
-  sessionKey: string;
-  channel: string;
-  chatId: string;
-  accountId?: string | null;
-}) => string[];
 type NextclawNcpContextBuilderOptions = {
   sessionManager: SessionManager;
-  toolRegistry: NextclawNcpToolRegistry;
+  toolRegistry: ToolRuntimeRegistry;
   getConfig: () => Config;
-  resolveMessageToolHints?: MessageToolHintsResolver;
   assetStore?: LocalAssetStore | null;
 };
 declare class NextclawNcpContextBuilder implements NcpContextBuilder {
@@ -935,12 +1022,6 @@ declare function createAssetTools(params: {
 }): NcpTool[];
 //#endregion
 //#region src/features/session-request/utils/agent-runtime-session-request-dispatcher.utils.d.ts
-declare const AGENT_RUNTIME_SESSION_MESSAGE_INGRESS_TYPE: _$_nextclaw_shared0.TypedKey<AgentRuntimeSessionMessageRequest>;
-type AgentRuntimeSessionMessageRequest = {
-  message: NcpMessage;
-  requestId: string;
-  sessionId: string;
-};
 type AgentRuntimeSessionRequestDispatcherOptions = {
   eventBus: EventBus;
   ingress: Ingress;
@@ -960,6 +1041,12 @@ declare function dispatchAgentRuntimeSessionRequest(input: {
 }): Promise<void>;
 declare function createAgentRuntimeSessionRequestDispatcher(options: AgentRuntimeSessionRequestDispatcherOptions): SessionRequestDispatcher;
 //#endregion
+//#region src/features/extension-runtime/utils/extension-channel-catalog.utils.d.ts
+declare function listExtensionChannelIds(params: {
+  config: Config;
+  workspace: string;
+}): string[];
+//#endregion
 //#region src/utils/ncp-session-summary.utils.d.ts
 declare function createNcpSessionSummary(params: {
   sessionId: string;
@@ -976,4 +1063,24 @@ declare function createNcpSessionSummary(params: {
 declare function toNcpMessages(sessionId: string, messages: SessionMessage[]): NcpMessage[];
 declare function resolveLegacyEventType(message: SessionMessage): string;
 //#endregion
-export { AGENT_RUNTIME_SESSION_MESSAGE_INGRESS_TYPE, AgentId, AgentManager, AgentRecord, AgentRuntimeContribution, AgentRuntimeEndpoint, AgentRuntimeEntry, type AgentRuntimeHandle, AgentRuntimeManager, AgentRuntimeManagerOptions, AgentRuntimeProviderRegistration, AgentRuntimeRegistry, AgentRuntimeSessionMessageRequest, AgentRuntimeSessionRequestDispatcherOptions, AgentRuntimeSessionTypeDescribeParams, AgentRuntimeSessionTypeIcon, AgentRuntimeSessionTypeOption, AutomationId, AutomationManager, AutomationManagerOptions, BuiltinNarpRuntimeRegistrationService, ChannelId, ChannelManager, ChannelReplyRouterDispatchParams, ConfigManager, ConfigManagerOptions, ConfigManagerRuntimeHooks, ContextCompactionPendingWork, ContextCompactionPreflightBeginResult, ContextCompactionPreflightResult, ContextCompactionPreflightService, ContextWindowOwner, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DEFAULT_LEARNING_LOOP_TOOL_CALL_THRESHOLD, DirectPromptDispatchParams, ExtensionContributions, ExtensionManager, GatewayInboundLoopRuntime, InstallationKind, LEARNING_LOOP_DISABLED_METADATA_KEY, LEARNING_LOOP_LAST_REQUESTED_AT_METADATA_KEY, LEARNING_LOOP_LAST_REVIEW_SESSION_ID_METADATA_KEY, LEARNING_LOOP_LAST_TOOL_CALL_COUNT_METADATA_KEY, LEARNING_LOOP_REQUESTED_SKILLS, LEARNING_LOOP_SOURCE_SESSION_ID_METADATA_KEY, LearningLoopManager, LearningLoopManagerOptions, LearningLoopRuntimeConfig, LearningLoopSessionRequester, LlmProviderManager, LlmProviderRuntime, LlmUsageManager, LlmUsageManagerOptions, LlmUsageRecord, LlmUsageSnapshot, LlmUsageStore, LlmUsageStoreOptions, LlmUsageSummary, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NativeAgentRuntimeFactory, NativeAgentRuntimeFactoryOptions, NativeRuntimeFactory, NcpRunnerAgent, NcpSessionApiService, NcpSessionApiServiceOptions, NextclawExtensionRegistry, NextclawKernel, NextclawKernelOptions, NextclawNcpContextBuilder, NextclawNcpToolRegistry, PluginRuntimeRegistrationController, ProviderManagerNcpLLMApi, RunPromptOverNcpParams, SessionId, SkillId, SkillManager, SkillRecord, StreamPromptOverNcpParams, TaskId, ToolId, ToolManager, ToolRecord, UnsignedUpdateManifest, UpdateBlockReason, UpdateHostKind, UpdateManifest, UpdateManifestReader, UpdatePreferences, UpdateProgress, UpdateSnapshot, UpdateStatus, UpdateToolCallResult, buildLearningLoopTask, buildLlmUsageSummary, buildNcpUserMessage, buildUserMessageParts, createAgentRuntimeHandle, createAgentRuntimeSessionRequestDispatcher, createAssetTools, createLlmUsageRecord, createNcpSessionSummary, dispatchAgentRuntimeSessionRequest, dispatchChannelReplyRoute, dispatchPromptOverNcp, getUnsignedUpdateManifest, hasLlmUsageTelemetry, isReplyCapableChannel, normalizeAgentRuntimeSessionTypeIcon, normalizeLlmUsageModel, readAccountIdForHints, readLearningLoopRuntimeConfig, resolveAgentHandoffDepth, resolveAgentRuntimeEntries, resolveChannelReplyRoute, resolveLegacyEventType, runGatewayInboundLoop, runPromptOverNcp, sanitizeLlmUsage, serializeUnsignedUpdateManifest, streamPromptOverNcp, toNcpMessages, waitForAgentRuntimeSessionReply };
+//#region src/types/tool.types.d.ts
+type ToolRecord = {
+  id: ToolId;
+  name: string;
+  description: string;
+  inputSchema?: Record<string, unknown>;
+  enabled: boolean;
+  metadata: Record<string, unknown>;
+};
+//#endregion
+//#region src/types/skill.types.d.ts
+type SkillRecord = {
+  id: SkillId;
+  name: string;
+  description: string;
+  toolIds: ToolId[];
+  enabled: boolean;
+  metadata: Record<string, unknown>;
+};
+//#endregion
+export { AgentId, AgentManager, AgentRecord, AgentRunRequestManager, AgentRuntimeEntry, AgentRuntimeManager, AgentRuntimeManagerOptions, AgentRuntimeProviderRegistration, AgentRuntimeRegistry, AgentRuntimeSessionRequestDispatcherOptions, AgentRuntimeSessionTypeDescribeParams, AgentRuntimeSessionTypeIcon, AgentRuntimeSessionTypeOption, AutomationId, AutomationManager, AutomationManagerOptions, BuiltinNarpRuntimeProviderService, CONTEXT_COMPACTION_TIMELINE_KIND, ChannelId, ChannelManager, ChannelReplyRouterDispatchParams, ConfigManager, ConfigManagerOptions, ConfigManagerRuntimeHooks, ConfigMutationResult, ContextCompactionPendingWork, ContextCompactionPreflightBeginResult, ContextCompactionPreflightResult, ContextCompactionPreflightService, ContextCompactionTimelineCheckpoint, ContextWindowOwner, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DirectPromptDispatchParams, ExtensionLoadProgress, ExtensionLoadResult, ExtensionManager, ExtensionPluginLoadProgress, ExtensionPluginRegistryService, GatewayInboundLoopRuntime, GatewayInboundProcessor, InstallationKind, InstalledSkillDetail, InstalledSkillSummary, InstalledSkillsList, type LearningLoopRuntimeConfig, LlmProviderManager, LlmProviderRuntime, LlmUsageManager, LlmUsageManagerOptions, LlmUsageRecord, LlmUsageSnapshot, LlmUsageStats, LlmUsageStore, LlmUsageStoreOptions, LlmUsageSummary, LocalizedTextMap, McpManager, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NEXTCLAW_TIMELINE_KIND_METADATA_KEY, NativeAgentRuntimeFactory, NativeAgentRuntimeFactoryOptions, NativeRuntimeFactory, NcpRunnerAgent, NcpSessionApiService, NcpSessionApiServiceOptions, NextclawKernel, NextclawKernelOptions, NextclawNcpContextBuilder, ProviderManagerNcpLLMApi, RunPromptOverNcpParams, SessionId, SessionRunManager, SkillFrontmatter, SkillId, type SkillInfo, SkillManager, SkillRecord, type SkillScope, StreamPromptOverNcpParams, TaskId, ToolId, ToolManager, ToolProvider, ToolRecord, ToolRegistrationContext, ToolRunContext, ToolRuntimeRegistry, ToolRuntimeRegistryOptions, UnsignedUpdateManifest, UpdateBlockReason, UpdateHostKind, UpdateManifest, UpdateManifestReader, UpdatePreferences, UpdateProgress, UpdateSnapshot, UpdateStatus, UpdateToolCallResult, buildContextCompactionTimelineNcpMessage, buildLlmUsageSummary, buildLocalizedTextMap, buildNcpUserMessage, buildUserMessageParts, createAgentRuntimeSessionRequestDispatcher, createAssetTools, createLlmUsageRecord, createNcpSessionSummary, dispatchAgentRuntimeSessionRequest, dispatchChannelReplyRoute, dispatchPromptOverNcp, getUnsignedUpdateManifest, hasLlmUsageTelemetry, isContextCompactionTimelineMessage, isReplyCapableChannel, listExtensionChannelIds, normalizeAgentRuntimeSessionTypeIcon, normalizeLlmUsageModel, parseSkillFrontmatter, projectNcpMessagesWithContextCompaction, readLearningLoopRuntimeConfig, resolveAgentHandoffDepth, resolveAgentRuntimeEntries, resolveChannelReplyRoute, resolveLegacyEventType, runGatewayInboundLoop, runPromptOverNcp, sanitizeLlmUsage, serializeUnsignedUpdateManifest, streamPromptOverNcp, stripSkillFrontmatter, toNcpMessages, upsertContextCompactionTimelineMessage, waitForAgentRuntimeSessionReply };