@nextclaw/kernel 0.9.1 → 0.10.0-beta.0

package/dist/index.d.ts

@@ -1,11 +1,13 @@
 import { AUTOMATIC_UPDATE_CHECK_INTERVAL_MS, getAutomaticUpdateCheckDelay, resolveAutomaticUpdateCheckIntervalMs } from "./utils/automatic-update-check.utils.js";
 import { a as getUnsignedUpdateManifest, c as UpdateBlockReason, d as UpdateStatus, i as UpdateManifestReader, l as UpdateProgress, n as UpdateHostKind, o as serializeUnsignedUpdateManifest, r as UpdateManifest, s as InstallationKind, t as UnsignedUpdateManifest, u as UpdateSnapshot } from "./update-manifest.types-CQpbURTE.js";
-import { BaseChannel, Config, ContextCompactionCheckpoint, ContextCompactionPhase, ContextCompactionPlan, ContextWindowSnapshot, CreateAgentProfileInput, CreateSessionContextInheritanceInput, CreateSessionInput, CreatedSession, CronService, DiagnosticRuntime, EffectiveAgentProfile, ExtensionChannelBinding, ExtensionDiagnostic, ExtensionRegistry, ExtensionUiMetadata, GatewayController, InboundAttachment, InboundMessage, LLMProvider, LLMResponse, LLMStreamEvent, MessageBus, ModelThinkingCapability, OutboundMessage, ProviderModelDiscoveryResult, RequestSessionParams, RequestedSkillsMetadataReader, SearchConfig, SessionMessage, SessionRequestDispatcher, SessionRequestRecord, SessionRequestToolResult, SessionSearchService, SkillInfo, SkillInfo as SkillInfo$1, SkillScope, SpawnSessionAndRequestParams, ThinkingLevel, UpdateAgentProfileInput, buildCompressingCompactionCheckpoint, resolveThinkingLevel } from "@nextclaw/core";
-import { ListMessagesOptions, ListSessionsOptions, NcpAgentConversationStateManager, NcpAgentRuntime, NcpEndpointEvent, NcpEventType, NcpInputDelivery, NcpLLMApi, NcpLLMApiInput, NcpLLMApiOptions, NcpMessage, NcpMessagePart, NcpRunHandle, NcpSessionApi, NcpSessionMessagePageInfo, NcpSessionPatch, NcpSessionSummary, NcpTool, OpenAIChatChunk } from "@nextclaw/ncp";
-import { AgentRunSendIngressPayload, EventBus, InboxDelivery, InboxDeliveryContentType, InboxDeliveryListView, InboxDeliverySource, InboxDeliveryStateAction, Ingress, RuntimeModelSelectionMode, SystemObjectReferenceGroupDescriptor, SystemObjectReferenceItem, SystemObjectReferenceListView, SystemObjectResolvedReference, Unsubscribe } from "@nextclaw/shared";
+import { BaseChannel, Config, ContextCompactionCheckpoint, ContextCompactionPhase, ContextCompactionPlan, ContextWindowSnapshot, CreateAgentProfileInput, CreateSessionContextInheritanceInput, CreateSessionInput, CreatedSession, CronService, DiagnosticRuntime, EffectiveAgentProfile, ExtensionChannelBinding, ExtensionDiagnostic, ExtensionRegistry, ExtensionUiMetadata, GatewayController, InboundAttachment, InboundMessage, LLMProvider, LLMResponse, LLMResponse as LLMResponse$1, LLMStreamEvent, LLMStreamEvent as LLMStreamEvent$1, McpServerDefinition, McpServerDefinition as McpServerDefinition$1, MessageBus, ModelThinkingCapability, OutboundMessage, ProviderCatalogPlugin, ProviderCatalogPlugin as ProviderCatalogPlugin$1, ProviderModelDiscoveryResult, ProviderSpec, ProviderSpec as ProviderSpec$1, RequestSessionParams, RequestedSkillsMetadataReader, SearchConfig, SessionMessage, SessionRequestDispatcher, SessionRequestRecord, SessionRequestToolResult, SessionSearchService, SkillInfo, SkillInfo as SkillInfo$1, SkillScope, SpawnSessionAndRequestParams, ThinkingLevel, UpdateAgentProfileInput, buildCompressingCompactionCheckpoint, resolveThinkingLevel } from "@nextclaw/core";
+import { ListMessagesOptions, ListSessionsOptions, NcpAgentConversationStateManager, NcpAgentRuntime, NcpContextTail, NcpEndpointEvent, NcpEndpointEvent as NcpEndpointEvent$1, NcpEventType, NcpInputDelivery, NcpJsonValue, NcpLLMApi, NcpLLMApiInput, NcpLLMApiOptions, NcpMessage, NcpMessage as NcpMessage$1, NcpMessagePart, NcpResolvedInputDelivery, NcpRunHandle, NcpSessionApi, NcpSessionMessagePageInfo, NcpSessionPatch, NcpSessionSummary, NcpTool, NcpTool as NcpTool$1, OpenAIChatChunk, OpenAIChatMessage } from "@nextclaw/ncp";
+import { AgentRunSendIngressPayload, AppEventEmitOptions, AppEventEnvelope, AppEventHandler, AppEventKey, Contribution as Contribution$1, Disposer, Disposer as Disposer$1, EventBus, EventBus as EventBus$1, EventBusOptions, InboxDelivery, InboxDeliveryContentType, InboxDeliveryListView, InboxDeliverySource, InboxDeliveryStateAction, Ingress, Ingress as Ingress$1, IngressContext, IngressEnvelope, IngressHandler, Key, RuntimeModelSelectionMode, SystemObjectReferenceGroupDescriptor, SystemObjectReferenceItem, SystemObjectReferenceListView, SystemObjectResolvedReference, TypedKey, Unsubscribe, Unsubscribe as Unsubscribe$1, createTypedKey, eventKeys, ingressKeys } from "@nextclaw/shared";
 import { LocalAssetStore } from "@nextclaw/ncp-agent-runtime";
-import { AppInstallProgressHandler, AppNativeArtifactTarget, AppPlatformTargetService, AppRollbackResult, AppRuntimeIsolation, AppRuntimeProfile, AppStorageContext, AppStorageUsage, AppUninstallResult, AppUpdateResult } from "@nextclaw/app-runtime";
 import { AgentSessionRecord, ChatTarget, NcpReplyInput, RuntimeFactoryParams } from "@nextclaw/ncp-toolkit";
+import { AppInstallProgressHandler, AppNativeArtifactTarget, AppPlatformTargetService, AppRollbackResult, AppRuntimeIsolation, AppRuntimeProfile, AppStorageContext, AppStorageUsage, AppUninstallResult, AppUpdateResult } from "@nextclaw/app-runtime";
+import * as _$_nextclaw_mcp0 from "@nextclaw/mcp";
+import { McpCatalogFilter, McpCatalogFilter as McpCatalogFilter$1, McpRegistryService, McpServerRecord, McpServerRecord as McpServerRecord$1, McpToolCatalogEntry, McpToolCatalogEntry as McpToolCatalogEntry$1 } from "@nextclaw/mcp";
 
 //#region src/features/runtime-registry/utils/agent-runtime-registry.utils.d.ts
 type AgentRuntimeSessionTypeIcon = {
@@ -145,8 +147,8 @@ type ProviderChatParams = {
 };
 type LlmProviderRuntime = {
   get: (model?: string | null) => LLMProvider;
-  chat: (params: ProviderChatParams) => Promise<LLMResponse>;
-  chatStream: (params: ProviderChatParams) => AsyncGenerator<LLMStreamEvent>;
+  chat: (params: ProviderChatParams) => Promise<LLMResponse$1>;
+  chatStream: (params: ProviderChatParams) => AsyncGenerator<LLMStreamEvent$1>;
 };
 type ProviderConnectionTestInput = {
   providerName: string | null;
@@ -168,18 +170,22 @@ type ProviderModelsDiscoverInput = {
 };
 declare class LlmProviderManager {
   private readonly providerRegistry;
+  private readonly contributedProviderPlugins;
   private readonly providerModelDiscovery;
   private readonly providerPool;
   private readonly missingProvider;
   private config;
   constructor();
+  registerProviderPlugin: (plugin: ProviderCatalogPlugin$1) => (() => void);
+  listProviderSpecs: () => readonly ProviderSpec$1[];
   load: (config: Config) => void;
   get: (model?: string | null) => LLMProvider;
-  readonly chat: (params: ProviderChatParams) => Promise<LLMResponse>;
-  readonly chatStream: (this: LlmProviderManager, params: ProviderChatParams) => AsyncGenerator<LLMStreamEvent>;
+  readonly chat: (params: ProviderChatParams) => Promise<LLMResponse$1>;
+  readonly chatStream: (this: LlmProviderManager, params: ProviderChatParams) => AsyncGenerator<LLMStreamEvent$1>;
   readonly testConnection: (input: ProviderConnectionTestInput) => Promise<void>;
   supportsModelDiscovery: (providerName: string | null) => boolean;
   discoverModels: (input: ProviderModelsDiscoverInput) => Promise<ProviderModelDiscoveryResult>;
+  private refreshProviderRegistry;
   private resolveRoute;
   private resolveProvider;
   private matchPrefixedProvider;
@@ -291,7 +297,7 @@ declare class ConfigManager {
   loadConfig: () => Config;
   getDefaultModel: () => string;
   getModelMaxTokens: (model: string) => number | undefined;
-  installRuntimeHooks: (hooks: ConfigManagerRuntimeHooks) => void;
+  installRuntimeHooks: (hooks: ConfigManagerRuntimeHooks) => (() => void);
   applyLiveConfigReload: () => Promise<void>;
   applyReloadPlan: (nextConfig: Config) => Promise<void>;
   private recordConfigEvent;
@@ -361,11 +367,11 @@ declare class AgentManager {
 //#endregion
 //#region src/types/agent-run.types.d.ts
 type ThinkingEffort = string;
-type ContextBlock = string;
+type ContextBlock$1 = string;
 type AgentRunRequest = {
   sessionId?: string;
   peerId?: string;
-  message: NcpMessage;
+  message: NcpMessage$1;
   agentRuntimeId?: string;
   agentId?: string;
   projectRoot?: string;
@@ -376,12 +382,13 @@ type AgentRunRequest = {
   maxTokens?: number;
   thinkingEffort?: ThinkingEffort | null;
   delivery?: NcpInputDelivery;
+  idempotencyKey?: string;
 };
 type SessionQueuedInput = {
   id: string;
   sessionId: string;
   enqueuedAt: string;
-  message: NcpMessage;
+  message: NcpMessage$1;
   metadata: Record<string, unknown>;
 };
 type SessionPendingInput = SessionQueuedInput & {
@@ -405,18 +412,18 @@ type AgentRunSpec = {
   thinkingEffort?: ThinkingEffort | null;
   correlationId?: string;
 };
-type ContextProvider = {
-  provide: (request: AgentRunRequest) => Promise<readonly ContextBlock[]> | readonly ContextBlock[];
+type ContextProvider$1 = {
+  provide: (request: AgentRunRequest) => Promise<readonly ContextBlock$1[]> | readonly ContextBlock$1[];
 };
 type ToolProvider = {
-  provide: (request: AgentRunRequest) => Promise<readonly NcpTool[]> | readonly NcpTool[];
+  provide: (request: AgentRunRequest) => Promise<readonly NcpTool$1[]> | readonly NcpTool$1[];
 };
 //#endregion
 //#region src/managers/context-provider.manager.d.ts
 declare class ContextProviderManager {
   private readonly providers;
-  register: (provider: ContextProvider) => (() => void);
-  buildContext: (request: AgentRunRequest) => Promise<readonly ContextBlock[]>;
+  register: (provider: ContextProvider$1) => (() => void);
+  buildContext: (request: AgentRunRequest) => Promise<readonly ContextBlock$1[]>;
   dispose: () => void;
 }
 //#endregion
@@ -439,7 +446,7 @@ declare class ToolProviderManager {
   private readonly providers;
   constructor(diagnostics?: Pick<DiagnosticRuntime, "record"> | undefined);
   register: (provider: ToolProvider) => (() => void);
-  buildTools: (request: AgentRunRequest) => Promise<readonly NcpTool[]>;
+  buildTools: (request: AgentRunRequest) => Promise<readonly NcpTool$1[]>;
   dispose: () => void;
   private readonly wrapTool;
 }
@@ -454,7 +461,7 @@ type AgentContextWindowEvaluation = {
 };
 type AgentRunSurface = {
   contextBlocks: readonly string[];
-  tools: readonly NcpTool[];
+  tools: readonly NcpTool$1[];
 };
 declare class AgentContextWindowManager {
   private readonly agentManager;
@@ -468,7 +475,7 @@ declare class AgentContextWindowManager {
   previewSession: (params: {
     requestMetadata: Record<string, unknown>;
     sessionId: string;
-    sessionMessages: readonly NcpMessage[];
+    sessionMessages: readonly NcpMessage$1[];
     storedAgentId?: string;
     storedMetadata: Record<string, unknown>;
   }) => Promise<ContextWindowSnapshot | null>;
@@ -489,18 +496,18 @@ type AgentRunContextCompactionInput = {
   sessionId: string;
   agentId: string;
   contextBlocks: readonly string[];
-  messages: readonly NcpMessage[];
+  messages: readonly NcpMessage$1[];
   metadata: Record<string, unknown>;
   model: string;
   phase?: ContextCompactionPhase;
   signal?: AbortSignal;
-  tools?: readonly NcpTool[];
+  tools?: readonly NcpTool$1[];
 };
 declare class AgentRunContextCompactionManager {
   private readonly preflightService;
   constructor(agentManager: AgentManager, providerManager: LlmProviderRuntime);
-  runPreflight: (input: AgentRunContextCompactionInput) => AsyncIterable<NcpEndpointEvent>;
-  runManual: (input: AgentRunContextCompactionInput) => Promise<readonly NcpEndpointEvent[]>;
+  runPreflight: (input: AgentRunContextCompactionInput) => AsyncIterable<NcpEndpointEvent$1>;
+  runManual: (input: AgentRunContextCompactionInput) => Promise<readonly NcpEndpointEvent$1[]>;
   private run;
   private toEvent;
 }
@@ -512,7 +519,7 @@ declare const NCP_SESSION_REQUEST_COMPLETED_EVENT_TYPE = "session.request.comple
 declare const NCP_SESSION_REQUEST_FAILED_EVENT_TYPE = "session.request.failed";
 type NcpAgentSessionSnapshotMessageEvent = {
   type: typeof NCP_AGENT_SESSION_SNAPSHOT_MESSAGE_EVENT_TYPE;
-  payload: Extract<NcpEndpointEvent, {
+  payload: Extract<NcpEndpointEvent$1, {
     type: NcpEventType.MessageSent;
   }>["payload"];
 };
@@ -524,7 +531,7 @@ type NcpSessionRequestJournalEvent = {
     request: unknown;
   };
 };
-type NcpAgentSessionJournalReplayEvent = NcpEndpointEvent | NcpAgentSessionSnapshotMessageEvent | NcpSessionRequestJournalEvent;
+type NcpAgentSessionJournalReplayEvent = NcpEndpointEvent$1 | NcpAgentSessionSnapshotMessageEvent | NcpSessionRequestJournalEvent;
 //#endregion
 //#region src/utils/ncp-agent-unfinished-run.utils.d.ts
 type UnfinishedNcpAgentRun = {
@@ -536,7 +543,7 @@ type UnfinishedNcpAgentRun = {
 //#endregion
 //#region src/types/session.types.d.ts
 type SessionMessagePage = {
-  messages: NcpMessage[];
+  messages: NcpMessage$1[];
   messageDetailCursors: Record<string, string>;
   total: number;
   pageInfo: NcpSessionMessagePageInfo;
@@ -622,6 +629,7 @@ declare class NcpAgentSessionJournalStore {
   private readonly summaryIndexStore;
   private readonly summaryReadStore;
   constructor(journalDir: string);
+  initialize: () => Promise<void>;
   appendSessionEvent: (params: {
     sessionId: string;
     event: NcpAgentSessionJournalReplayEvent;
@@ -632,7 +640,7 @@ declare class NcpAgentSessionJournalStore {
   }) => Promise<NcpSessionSummary[]>;
   getSessionSummary: (sessionId: string) => Promise<NcpSessionSummary | null>;
   listUnfinishedRuns: () => Promise<UnfinishedNcpAgentRun[]>;
-  listSessionMessages: (sessionId: string) => Promise<NcpMessage[]>;
+  listSessionMessages: (sessionId: string) => Promise<NcpMessage$1[]>;
   listSessionMessagePage: (params: {
     sessionId: string;
     limit: number;
@@ -723,14 +731,17 @@ type SessionManagerOptions = {
   agentContextWindowManager: AgentContextWindowManager;
   agentManager: AgentManager;
   configManager: ConfigManager;
-  eventBus: EventBus;
+  eventBus: EventBus$1;
   journalStore: NcpAgentSessionJournalStore;
   projectManager: ProjectManager;
   sessionSearch: SessionSearchService;
+  beforeDeleteSession?: (sessionId: string) => Promise<void>;
 };
 declare class SessionManager implements NcpSessionApi {
   private readonly options;
   private readonly eventIngestion;
+  private readonly settings;
+  private readonly summaryProjection;
   private readonly workingDirResolver;
   constructor(options: SessionManagerOptions);
   start: () => Promise<void>;
@@ -749,7 +760,7 @@ declare class SessionManager implements NcpSessionApi {
   deleteSession: (sessionId: string) => Promise<void>;
   getSessionRecord: (sessionId: string) => Promise<AgentSessionRecord | null>;
   listSessions: (options?: ListSessionsOptions) => Promise<NcpSessionSummary[]>;
-  listSessionMessages: (sessionId: string, options?: ListMessagesOptions) => Promise<NcpMessage[]>;
+  listSessionMessages: (sessionId: string, options?: ListMessagesOptions) => Promise<NcpMessage$1[]>;
   getSessionTokenUsage: (sessionId: string) => Promise<SessionTokenUsageSummary | null>;
   listSessionMessagePage: (sessionId: string, options: {
     limit: number;
@@ -764,10 +775,6 @@ declare class SessionManager implements NcpSessionApi {
   clearSessionMessages: (sessionId: string) => Promise<number>;
   rewindSessionBeforeMessage: (sessionId: string, messageId: string) => Promise<AgentSessionRecord>;
   publishSessionChange: (sessionKey: string) => Promise<void>;
-  private createSummaryFromRecord;
-  private createSummaryWithContextWindow;
-  private publishSessionMetadataChanged;
-  private applySessionProjectPatch;
 }
 //#endregion
 //#region src/types/product-activity.types.d.ts
@@ -808,13 +815,13 @@ declare class SessionRun {
   private activeProductActivitySource;
   constructor(seed: {
     sessionId: string;
-    messages: readonly NcpMessage[];
+    messages: readonly NcpMessage$1[];
   }, stateManager?: NcpAgentConversationStateManager, productActivitySink?: ProductActivitySink | undefined);
   getSnapshot: () => {
-    messages: readonly NcpMessage[];
+    messages: readonly NcpMessage$1[];
   };
-  applyEvents: (events: readonly NcpEndpointEvent[]) => Promise<void>;
-  replaceMessages: (messages: readonly NcpMessage[]) => void;
+  applyEvents: (events: readonly NcpEndpointEvent$1[]) => Promise<void>;
+  replaceMessages: (messages: readonly NcpMessage$1[]) => void;
   onStatusChange: (listener: (status: "idle" | "running") => void) => (() => void);
   enqueueRequest: (request: AgentRunRequest, session: AgentRunSession) => SessionRunQueuedRequest;
   listQueuedRequests: () => readonly SessionRunQueuedRequest[];
@@ -851,14 +858,14 @@ declare class SessionRunManager {
 type AgentRuntimeRunOptions = {
   session: AgentRunSession;
   sessionRun: SessionRun;
-  contextBlocks: readonly ContextBlock[];
-  tools: readonly NcpTool[];
-  initialMessages: readonly NcpMessage[];
+  contextBlocks: readonly ContextBlock$1[];
+  tools: readonly NcpTool$1[];
+  initialMessages: readonly NcpMessage$1[];
   signal?: AbortSignal;
 };
 type AgentRuntimeContextCompactionOptions = Pick<AgentRuntimeRunOptions, "session" | "sessionRun">;
 type AgentRuntimeContextCompactionResult = {
-  events: readonly NcpEndpointEvent[];
+  events: readonly NcpEndpointEvent$1[];
   performed: boolean;
   supported: boolean;
 };
@@ -866,7 +873,7 @@ type AgentRuntime = {
   capabilities?: {
     nextStepInput?: boolean;
   };
-  run: (spec: AgentRunSpec, options: AgentRuntimeRunOptions) => AsyncIterable<NcpEndpointEvent>;
+  run: (spec: AgentRunSpec, options: AgentRuntimeRunOptions) => AsyncIterable<NcpEndpointEvent$1>;
   compactContext?: (options: AgentRuntimeContextCompactionOptions) => Promise<AgentRuntimeContextCompactionResult>;
   dispose?: () => Promise<void> | void;
 };
@@ -894,10 +901,16 @@ type AgentRuntimeCacheParams = {
 declare class AgentRuntimeManager {
   private readonly providers;
   private readonly entries;
+  private readonly configuredEntries;
+  private readonly contributedEntries;
   private readonly globalRuntimes;
   private readonly sessionRuntimes;
   register: (registration: AgentRuntimeRegistration) => (() => Promise<void>);
+  registerProvider: (provider: AgentRuntimeProviderRegistration, host: {
+    resolveAssetContentPath: (assetUri: string) => string | null;
+  }) => (() => Promise<void>);
   applyEntries: (entries: readonly AgentRuntimeEntry[]) => void;
+  registerEntry: (entry: AgentRuntimeEntry) => (() => Promise<void>);
   getOrCreate: (params: AgentRuntimeCacheParams) => AgentRuntime;
   disposeRuntime: (params: AgentRuntimeCacheParams) => Promise<boolean>;
   listSessionTypes: (params?: AgentRuntimeSessionTypeDescribeParams) => Promise<{
@@ -906,6 +919,7 @@ declare class AgentRuntimeManager {
   }>;
   dispose: () => Promise<void>;
   private normalizeId;
+  private rebuildEntries;
   private getEntry;
   private getProvider;
   private resolveReuseScope;
@@ -945,9 +959,11 @@ declare class AgentRunRequestManager {
   readonly cleanups: Array<() => void>;
   private readonly observedSessionRuns;
   private readonly sessionCommandManager;
+  private readonly idempotency;
+  private readonly runtimeRuns;
   readonly pendingInputs: AgentRunInputDeliveryService;
   private started;
-  constructor(agentRuntimeManager: AgentRuntimeManager, agentManager: AgentManager, configManager: ConfigManager, agentContextWindowManager: AgentContextWindowManager, eventBus: EventBus, ingress: Ingress, sessionManager: SessionManager, sessionRunManager: SessionRunManager, diagnostics?: Pick<DiagnosticRuntime, "record"> | undefined);
+  constructor(agentRuntimeManager: AgentRuntimeManager, agentManager: AgentManager, configManager: ConfigManager, agentContextWindowManager: AgentContextWindowManager, eventBus: EventBus$1, ingress: Ingress$1, sessionManager: SessionManager, sessionRunManager: SessionRunManager, diagnostics?: Pick<DiagnosticRuntime, "record"> | undefined);
   start: () => void;
   dispose: () => void;
   private handleSendRequest;
@@ -956,6 +972,7 @@ declare class AgentRunRequestManager {
   private handleContinueRequest;
   private handleSessionMessageRequest;
   private send;
+  private sendOnce;
   private startQueuedRun;
   private startRuntimeRun;
   private publishRunStartupFailure;
@@ -1313,6 +1330,343 @@ declare class AppDataManager {
   private isMissingFileError;
 }
 //#endregion
+//#region src/features/observation/types/observation.types.d.ts
+type JsonValue = NcpJsonValue;
+type ObservationCapabilityDescriptor = {
+  extensionId: string;
+  kind: "context" | "events";
+  title: string;
+  description?: string;
+  configSchema?: Record<string, unknown>;
+  replay?: "supported" | "unsupported";
+};
+type ObservationTarget = {
+  sessionId: string;
+  agentId: string;
+};
+type ObservationEvent = {
+  eventId: string;
+  eventType: string;
+  occurredAt: string;
+  observedAt: string;
+  cursor?: string;
+  dedupeKey?: string;
+  causationId?: string;
+  correlationId?: string;
+  payload: JsonValue;
+  sourceRefs?: string[];
+};
+type ObservationRelationshipStatus = "active" | "paused" | "degraded" | "expired" | "broken";
+type ContextBinding = {
+  bindingId: string;
+  extensionId: string;
+  config: JsonValue;
+  target: ObservationTarget;
+  projection: {
+    maxChars?: number;
+    maxItems?: number;
+  };
+  status: ObservationRelationshipStatus;
+  statusReason?: string;
+  createdAt: string;
+  expiresAt?: string;
+  lastReadAt?: string;
+};
+type JsonPointer = string;
+type TypedPredicate = {
+  op: "exists";
+  path: JsonPointer;
+} | {
+  op: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "contains";
+  path: JsonPointer;
+  value: JsonValue;
+} | {
+  op: "and";
+  args: TypedPredicate[];
+} | {
+  op: "or";
+  args: TypedPredicate[];
+} | {
+  op: "not";
+  arg: TypedPredicate;
+};
+type EventAdmissionPolicy = {
+  predicate?: TypedPredicate;
+  dedupe?: {
+    key: JsonPointer;
+    window?: string;
+  };
+};
+type EventSubscriptionBudget = {
+  maxPending: number;
+  maxDeliveriesPerWindow?: number;
+  window?: string;
+};
+type EventSubscription = {
+  subscriptionId: string;
+  extensionId: string;
+  config: JsonValue;
+  target: ObservationTarget;
+  admission: EventAdmissionPolicy;
+  delivery: "queue" | "prefer-steer";
+  budget: EventSubscriptionBudget;
+  cursor?: string;
+  status: ObservationRelationshipStatus;
+  statusReason?: string;
+  createdAt: string;
+  expiresAt?: string;
+  suppressedCount?: number;
+  lastSuppressedAt?: string;
+  lastSuppressionReason?: "predicate" | "dedupe" | "max_pending" | "rate_limit";
+  lastGapAt?: string;
+  gapReason?: "replay_unsupported";
+};
+type EventDelivery = {
+  deliveryId: string;
+  subscriptionId: string;
+  eventId: string;
+  event: ObservationEvent;
+  dedupeValue?: string;
+  targetSessionId: string;
+  requestedDelivery: "queue" | "prefer-steer";
+  resolvedDelivery?: NcpResolvedInputDelivery;
+  status: "pending" | "submitted" | "materialized" | "failed";
+  ingressIdempotencyKey: string;
+  messageId: string;
+  createdAt: string;
+  updatedAt: string;
+  failure?: {
+    code: string;
+    message: string;
+  };
+};
+type ObservationState = {
+  bindings: ContextBinding[];
+  subscriptions: EventSubscription[];
+  deliveries: EventDelivery[];
+};
+type ObservationRef = {
+  kind: "context_binding";
+  id: string;
+} | {
+  kind: "event_subscription";
+  id: string;
+};
+type BindContextInput = {
+  extensionId: string;
+  config: JsonValue;
+  targetSessionId: string;
+  projection?: {
+    maxChars?: number;
+    maxItems?: number;
+  };
+  ttl?: string;
+};
+type SubscribeEventsInput = {
+  extensionId: string;
+  config: JsonValue;
+  targetSessionId: string;
+  admission?: EventAdmissionPolicy;
+  delivery?: "queue" | "prefer-steer";
+  budget?: Partial<EventSubscriptionBudget>;
+  ttl?: string;
+};
+type BuildContextTailInput = {
+  sessionId: string;
+  signal?: AbortSignal;
+};
+type ObservationContextTail = NcpContextTail;
+type ObservationExtensionRuntime = {
+  discoverObservations: (input?: {
+    query?: string;
+    kinds?: Array<"context" | "events">;
+  }) => ObservationCapabilityDescriptor[];
+  readObservation: (input: {
+    extensionId: string;
+    config: JsonValue;
+    signal?: AbortSignal;
+  }) => Promise<JsonValue>;
+  subscribeObservation: (input: {
+    extensionId: string;
+    subscriptionId: string;
+    config: JsonValue;
+    cursor?: string;
+  }) => Promise<{
+    replay: "supported" | "unsupported";
+  }>;
+  unsubscribeObservation: (input: {
+    extensionId: string;
+    subscriptionId: string;
+  }) => Promise<void>;
+};
+//#endregion
+//#region src/features/observation/managers/observation.manager.d.ts
+type ObservationManagerOptions = {
+  storePath: string;
+  sessionManager: SessionManager;
+  agentManager: AgentManager;
+  ingress: Ingress$1;
+  eventBus: EventBus$1;
+  now?: () => Date;
+};
+declare class ObservationManager {
+  private readonly options;
+  private readonly store;
+  private readonly context;
+  private readonly events;
+  private readonly cleanups;
+  private runtime;
+  private started;
+  constructor(options: ObservationManagerOptions);
+  setExtensionRuntime: (runtime: ObservationExtensionRuntime) => void;
+  start: () => Promise<void>;
+  dispose: () => Promise<void>;
+  bindContext: (input: BindContextInput) => Promise<ContextBinding>;
+  subscribeEvents: (input: SubscribeEventsInput) => Promise<EventSubscription>;
+  acceptExtensionEvent: (input: {
+    extensionId: string;
+    subscriptionId: string;
+    event: ObservationEvent;
+  }) => Promise<{
+    accepted: boolean;
+  }>;
+  onExtensionObservationRuntimeExited: (extensionId: string) => void;
+  onExtensionObservationRuntimeReady: (extensionId: string) => Promise<void>;
+  buildContextTail: (input: BuildContextTailInput) => Promise<ObservationContextTail | undefined>;
+  discoverObservations: (input?: {
+    query?: string;
+    kinds?: Array<"context" | "events">;
+  }) => ObservationCapabilityDescriptor[];
+  listObservations: (sessionId?: string) => Promise<{
+    bindings: ContextBinding[];
+    subscriptions: EventSubscription[];
+    deliveries: EventDelivery[];
+  }>;
+  getObservation: (ref: ObservationRef) => Promise<ContextBinding | EventSubscription | null>;
+  updateObservation: (action: "pause" | "resume" | "remove", ref: ObservationRef) => Promise<{
+    observation: ContextBinding | EventSubscription | null;
+    remainingDeliveries: number;
+  }>;
+  removeSession: (sessionId: string) => Promise<void>;
+  private revalidateSession;
+  private resolveNativeTarget;
+  private requireCapability;
+  private requireRuntime;
+  private requireString;
+  private runBackground;
+}
+//#endregion
+//#region src/features/observation/utils/observation.utils.d.ts
+declare function parseObservationDuration(value: string, field: string): number;
+declare function readJsonPointer(value: unknown, pointer: string): unknown;
+declare function assertObservationJsonValue(value: unknown, depth?: number): asserts value is JsonValue;
+declare function assertObservationPredicate(predicate: TypedPredicate, depth?: number): void;
+declare function matchesObservationPredicate(predicate: TypedPredicate | undefined, event: ObservationEvent): boolean;
+type ObservationEventAdmissionDecision = {
+  kind: "admitted";
+  delivery: EventDelivery;
+} | {
+  kind: "existing";
+  deliveryId: string;
+} | {
+  kind: "suppressed";
+  reason: "predicate" | "dedupe" | "max_pending" | "rate_limit";
+};
+declare function evaluateObservationEventAdmission(input: {
+  state: ObservationState;
+  subscription: EventSubscription;
+  event: ObservationEvent;
+  deliveryId: string;
+  now: Date;
+}): ObservationEventAdmissionDecision;
+declare function toBoundedJson(value: JsonValue, maxChars: number): JsonValue;
+declare function serializeContextTail(tail: NcpContextTail): string;
+declare function buildObservationEventModelMessage(message: NcpMessage$1): OpenAIChatMessage | null;
+//#endregion
+//#region src/features/extension-runtime/types/extension-runtime.types.d.ts
+type ExtensionServerConfig = {
+  type: "stdio";
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+};
+type ExtensionManifest = {
+  id: string;
+  name?: string;
+  version?: string;
+  rootDir: string;
+  server: ExtensionServerConfig;
+  contributes?: {
+    observations?: {
+      read?: {
+        description: string;
+        configSchema?: Record<string, unknown>;
+      };
+      events?: {
+        description: string;
+        configSchema?: Record<string, unknown>;
+        replay?: "supported" | "unsupported";
+      };
+    };
+    channels?: Array<{
+      id: string;
+      name?: string;
+      description?: string;
+      meta?: Record<string, unknown>;
+      configSchema?: Record<string, unknown>;
+      configUiHints?: Record<string, Record<string, unknown>>;
+      auth?: boolean | Record<string, unknown>;
+      outbound?: {
+        text?: boolean;
+      };
+    }>;
+  };
+};
+type ExtensionProcessState = "stopped" | "starting" | "running" | "stopping" | "failed";
+type ExtensionLeaseReason = {
+  kind: "enabled-channel";
+  channelId: string;
+} | {
+  kind: "auth-session";
+  sessionId: string;
+  expiresAt: string;
+} | {
+  kind: "auth-handoff";
+  channelId: string;
+  expiresAt: string;
+} | {
+  kind: "request";
+  requestId: string;
+} | {
+  kind: "observation-subscription";
+  subscriptionId: string;
+};
+type ExtensionRuntimeStatus = {
+  extensionId: string;
+  generation: string | null;
+  lastExit: {
+    at: string;
+    code: number | null;
+    expected: boolean;
+    signal: string | null;
+  } | null;
+  leaseReasons: ExtensionLeaseReason[];
+  memory: {
+    pssBytes: number | null;
+    rssBytes: number | null;
+  } | null;
+  pid: number | null;
+  startedAt: string | null;
+  state: ExtensionProcessState;
+  startupDurationMs: number | null;
+};
+//#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/managers/extension.manager.d.ts
 type ExtensionLoadProgress = {
   extensionId: string;
@@ -1328,10 +1682,11 @@ type ExtensionLoadResult = {
 type ExtensionManagerOptions = {
   diagnostics: DiagnosticRuntime;
   configManager: Pick<ConfigManager, "loadConfig">;
-  eventBus: Pick<EventBus, "emitEnvelope">;
-  ingress: Pick<Ingress, "addHandler">;
+  eventBus: Pick<EventBus$1, "emitEnvelope">;
+  ingress: Pick<Ingress$1, "addHandler">;
   messageBus: Pick<MessageBus, "publishInbound">;
   sessionManager: SessionManager;
+  observations: ObservationManager;
 };
 type ExtensionLoadParams = {
   config?: Config;
@@ -1359,6 +1714,7 @@ declare class ExtensionManager {
   getChannelBindings: () => ExtensionChannelBinding[];
   getUiMetadata: () => ExtensionUiMetadata[];
   getRuntimeStatus: () => ExtensionRuntimeStatus[];
+  getManifests: () => ExtensionManifest[];
   authenticateEventStreamCredential: (input: {
     extensionId: string | null;
     generation: string | null;
@@ -1476,7 +1832,7 @@ type CreateInboxDeliveryInput = {
   source: InboxDeliverySource;
 };
 type InboxDeliveryManagerOptions = {
-  eventBus: Pick<EventBus, "emit">;
+  eventBus: Pick<EventBus$1, "emit">;
   storePath: string;
 };
 type InboxDeliveryErrorCode = "INBOX_DELIVERY_INVALID_CONTENT" | "INBOX_DELIVERY_INVALID_SUMMARY" | "INBOX_DELIVERY_INVALID_TITLE" | "INBOX_DELIVERY_NOT_FOUND";
@@ -1541,7 +1897,9 @@ declare function createCronJobSystemObjectProvider(automation: Pick<AutomationMa
 //#endregion
 //#region src/managers/mcp.manager.d.ts
 declare class McpManager {
+  private baseConfig;
   private currentMcpConfig;
+  private readonly contributedServers;
   private readonly mcpLifecycleManager;
   private readonly mcpRegistryService;
   private readonly toolRegistryAdapter;
@@ -1549,10 +1907,15 @@ declare class McpManager {
   constructor(getConfig: () => Config);
   listToolsForRun: (params: {
     agentId: string;
-  }) => ReadonlyArray<NcpTool>;
+  }) => ReadonlyArray<NcpTool$1>;
+  registerServer: (name: string, definition: McpServerDefinition$1) => Promise<() => Promise<void>>;
+  listServers: () => _$_nextclaw_mcp0.McpServerRecord[];
+  listTools: (filter?: McpCatalogFilter$1) => _$_nextclaw_mcp0.McpToolCatalogEntry[];
+  callTool: (params: Parameters<McpRegistryService["callTool"]>[0]) => Promise<unknown>;
   start: () => void;
   applyConfig: (config: Config) => Promise<void>;
   dispose: () => Promise<void>;
+  private buildEffectiveConfig;
   private prewarmEnabledServersSafely;
 }
 //#endregion
@@ -1572,7 +1935,7 @@ declare class SessionContextCompactionManager {
   private readonly eventBus;
   private readonly sessionManager;
   private readonly sessionRunManager;
-  constructor(agentRuntimeManager: AgentRuntimeManager, eventBus: EventBus, sessionManager: SessionManager, sessionRunManager: SessionRunManager);
+  constructor(agentRuntimeManager: AgentRuntimeManager, eventBus: EventBus$1, sessionManager: SessionManager, sessionRunManager: SessionRunManager);
   compact: (requestedSessionId: string) => Promise<SessionContextCompactionResult>;
 }
 //#endregion
@@ -1753,7 +2116,7 @@ type PanelAppAgentSendPayload = {
 } | {
   sessionId?: string;
   peerId?: string;
-  message: NcpMessage | (Omit<NcpMessage, "sessionId"> & {
+  message: NcpMessage$1 | (Omit<NcpMessage$1, "sessionId"> & {
     sessionId?: string;
   });
   content?: never;
@@ -1765,7 +2128,7 @@ type PanelAppAgentSendRequest = {
 type PanelAppAgentSendResult = NcpRunHandle;
 type PanelAppAgentRunClient = {
   send: (input: AgentRunSendIngressPayload) => Promise<NcpRunHandle>;
-  sendAndStreamEvents: (input: AgentRunSendIngressPayload) => AsyncGenerator<NcpEndpointEvent>;
+  sendAndStreamEvents: (input: AgentRunSendIngressPayload) => AsyncGenerator<NcpEndpointEvent$1>;
 };
 type PanelAppAgentGenerateObjectInput = {
   peerId: string;
@@ -1802,8 +2165,8 @@ declare class PanelAppManager {
   constructor(params: {
     agentRunClient?: PanelAppAgentRunClient;
     configManager: ConfigManager;
-    eventBus?: EventBus;
-    ingress?: Ingress;
+    eventBus?: EventBus$1;
+    ingress?: Ingress$1;
     listPackageComponentSources?: () => Promise<AppPackageComponentSource[]>;
   });
   listPanelApps: () => Promise<PanelAppList>;
@@ -2092,19 +2455,19 @@ declare class SessionRequestManager {
 //#endregion
 //#region src/features/session-request/utils/agent-runtime-session-request-dispatcher.utils.d.ts
 type AgentRuntimeSessionRequestDispatcherOptions = {
-  eventBus: EventBus;
-  ingress: Ingress;
+  eventBus: EventBus$1;
+  ingress: Ingress$1;
 };
 declare function waitForAgentRuntimeSessionReply(input: {
-  eventBus: EventBus;
+  eventBus: EventBus$1;
   onAccepted: (messageId: string) => void;
   requestId: string;
 }): {
-  dispose: Unsubscribe;
-  promise: Promise<NcpMessage>;
+  dispose: Unsubscribe$1;
+  promise: Promise<NcpMessage$1>;
 };
 declare function dispatchAgentRuntimeSessionRequest(input: {
-  ingress: Ingress;
+  ingress: Ingress$1;
   request: SessionRequestRecord;
   task: string;
 }): Promise<void>;
@@ -2132,8 +2495,8 @@ declare class NextclawKernelControlManager<TGatewayInput, TUiInput, TStartInput>
   requireRuntimeControl: () => NextclawKernelRuntimeControl<TGatewayInput, TUiInput, TStartInput>;
 }
 declare class NextclawKernel {
-  readonly eventBus: EventBus;
-  readonly ingress: Ingress;
+  readonly eventBus: EventBus$1;
+  readonly ingress: Ingress$1;
   readonly messageBus: MessageBus;
   readonly diagnostics: DiagnosticRuntime;
   readonly llmProviders: LlmProviderManager;
@@ -2168,10 +2531,12 @@ declare class NextclawKernel {
   readonly sessionContextCompactionManager: SessionContextCompactionManager;
   readonly toolProviderManager: ToolProviderManager;
   readonly agentRunRequestManager: AgentRunRequestManager;
+  readonly observations: ObservationManager;
   private readonly ncpAgentSessionJournalStore;
   private readonly contributions;
   private gatewayController;
   constructor(options?: NextclawKernelOptions);
+  private createContributions;
   private installAppPackageRuntimeHooks;
   listSessionTypes: (params?: AgentRuntimeSessionTypeDescribeParams) => Promise<{
     defaultType: string;
@@ -2231,28 +2596,36 @@ declare function buildAgentRunSendPayload(params: BuildAgentRunSendPayloadParams
 type AgentRunReplyOptions = {
   abortSignal?: AbortSignal;
   onAssistantDelta?: (delta: string) => void;
-  onEvent?: (event: NcpEndpointEvent) => void;
+  onEvent?: (event: NcpEndpointEvent$1) => void;
   missingCompletedMessageError?: string;
   runErrorMessage?: string;
 };
 type AgentRunStreamOptions = {
   abortSignal?: AbortSignal;
-  onEvent?: (event: NcpEndpointEvent) => void;
+  onEvent?: (event: NcpEndpointEvent$1) => void;
 };
 type AgentRunReply = {
   handle: NcpRunHandle;
   text: string;
-  completedMessage: NcpMessage;
+  completedMessage: NcpMessage$1;
+};
+type AgentRunExecution = {
+  handle: NcpRunHandle;
+  events: AsyncIterable<NcpEndpointEvent$1>;
+  result: Promise<AgentRunReply>;
+  cancel: () => Promise<void>;
+  dispose: () => void;
 };
 declare class AgentRunClient {
   private readonly options;
   constructor(options: {
-    eventBus: Pick<EventBus, "on">;
-    ingress: Pick<Ingress, "handle">;
+    eventBus: Pick<EventBus$1, "on">;
+    ingress: Pick<Ingress$1, "handle">;
   });
   send: (input: AgentRunSendIngressPayload) => Promise<NcpRunHandle>;
   sendAndWaitForReply: (input: AgentRunSendIngressPayload, options?: AgentRunReplyOptions) => Promise<AgentRunReply>;
-  sendAndStreamEvents: (this: AgentRunClient, input: AgentRunSendIngressPayload, options?: AgentRunStreamOptions) => AsyncGenerator<NcpEndpointEvent>;
+  startRun: (input: AgentRunSendIngressPayload, options?: AgentRunReplyOptions) => Promise<AgentRunExecution>;
+  sendAndStreamEvents: (this: AgentRunClient, input: AgentRunSendIngressPayload, options?: AgentRunStreamOptions) => AsyncGenerator<NcpEndpointEvent$1>;
   private prepareObserver;
   private sendWithCorrelation;
 }
@@ -2270,7 +2643,7 @@ type GatewayInboundLoopRuntime = {
   configManager: {
     loadConfig: () => Config;
   };
-  appEventBus?: EventBus;
+  appEventBus?: EventBus$1;
 };
 declare class GatewayInboundProcessor {
   private runtime;
@@ -2304,7 +2677,7 @@ type ChannelReplyRouterDispatchParams = {
   attachments?: InboundAttachment[];
   metadata?: Record<string, unknown>;
   abortSignal?: AbortSignal;
-  onEvent?: (event: NcpEndpointEvent) => void;
+  onEvent?: (event: NcpEndpointEvent$1) => void;
 };
 declare function isReplyCapableChannel(channel: BaseChannel<Record<string, unknown>> | null | undefined): channel is ReplyCapableChannel;
 declare function resolveChannelReplyRoute(params: {
@@ -2327,9 +2700,244 @@ type DirectPromptDispatchParams = {
   agentId?: string;
   abortSignal?: AbortSignal;
   onAssistantDelta?: (delta: string) => void;
+  onEvent?: (event: NcpEndpointEvent$1) => void;
 };
+type DirectPromptDispatchResult = {
+  kind: "agent" | "command";
+  agentId: string;
+  sessionId: string;
+  runId: string | null;
+  text: string;
+  completedMessage: NcpMessage$1 | null;
+};
+type DirectPromptDispatchExecution = {
+  kind: "command";
+  result: DirectPromptDispatchResult;
+} | {
+  kind: "agent";
+  agentId: string;
+  sessionId: string;
+  execution: AgentRunExecution;
+};
+declare function startPromptOverNcpExecution(params: DirectPromptDispatchParams): Promise<DirectPromptDispatchExecution>;
+declare function dispatchPromptOverNcpResult(params: DirectPromptDispatchParams): Promise<DirectPromptDispatchResult>;
 declare function dispatchPromptOverNcp(params: DirectPromptDispatchParams): Promise<string>;
 //#endregion
+//#region src/features/harness/managers/nextclaw-contribution.manager.d.ts
+declare abstract class Contribution extends Contribution$1 {
+  readonly id: string;
+  readonly version?: string;
+  protected constructor(options: {
+    id: string;
+    version?: string;
+  });
+  protected get kernel(): IKernel;
+}
+//#endregion
+//#region src/features/harness/types/nextclaw-harness.types.d.ts
+type NextclawHarnessErrorCode = "invalid_input" | "cancelled" | "lifecycle" | "runtime_failure";
+declare class NextclawHarnessError extends Error {
+  readonly code: NextclawHarnessErrorCode;
+  readonly cause?: unknown;
+  constructor(code: NextclawHarnessErrorCode, message: string, cause?: unknown);
+}
+type NextclawTaskInput = {
+  input: string;
+  agentId?: string;
+  sessionId?: string;
+  model?: string;
+  signal?: AbortSignal;
+  onEvent?: (event: NcpEndpointEvent$1) => void;
+  onAssistantDelta?: (delta: string) => void;
+};
+type NextclawTaskResult = {
+  schemaVersion: "nextclaw.task/v1";
+  status: "completed";
+  kind: "agent" | "command";
+  agentId: string;
+  sessionId: string;
+  runId: string | null;
+  text: string;
+  completedMessage: NcpMessage$1 | null;
+};
+type NextclawHarnessOptions = {
+  homeDir?: string;
+  configPath?: string;
+  builtInAppsDirectory?: string;
+  productVersion?: string;
+  productActivitySink?: {
+    record: (signal: {
+      kind: "intent_accepted" | "run_succeeded";
+      occurredAt: string;
+      source: "direct" | "channel";
+    }) => Promise<void> | void;
+  };
+};
+type NextclawAgentDefinition = {
+  id: string;
+  displayName?: string;
+  description?: string;
+  model?: string;
+  runtime?: string;
+  runtimeConfig?: Record<string, unknown> | null;
+};
+type NextclawSessionCreateInput = {
+  sessionId?: string;
+  task: string;
+  title?: string;
+  workspace?: string;
+  model?: string;
+};
+type NextclawSessionRunInput = {
+  input: string;
+  model?: string;
+  signal?: AbortSignal;
+  onEvent?: (event: NcpEndpointEvent$1) => void;
+  onAssistantDelta?: (delta: string) => void;
+};
+type NextclawRunStatus = "running" | "completed" | "failed" | "cancelled";
+type NextclawContributionDescriptor = {
+  id: string;
+  version?: string;
+};
+interface IToolRegistry {
+  register(tool: NcpTool$1): Disposer$1;
+}
+type ContextBlock = string;
+type ContextProviderRequest = {
+  sessionId?: string;
+  peerId?: string;
+  message: NcpMessage$1;
+  agentRuntimeId?: string;
+  agentId?: string;
+  projectRoot?: string;
+  channel?: string;
+  correlationId?: string;
+  metadata?: Record<string, unknown>;
+  model?: string;
+  maxTokens?: number;
+  thinkingEffort?: string | null;
+};
+type ContextProvider = {
+  provide: (request: ContextProviderRequest) => Promise<readonly ContextBlock[]> | readonly ContextBlock[];
+};
+interface IContextRegistry {
+  register(provider: ContextProvider): Disposer$1;
+}
+type ModelChatInput = {
+  messages: Array<Record<string, unknown>>;
+  tools?: Array<Record<string, unknown>>;
+  model?: string | null;
+  maxTokens?: number;
+  thinkingLevel?: ThinkingLevel | null;
+  signal?: AbortSignal;
+};
+interface IModelRegistry {
+  registerProvider(plugin: ProviderCatalogPlugin$1): Disposer$1;
+  listProviders(): readonly ProviderSpec$1[];
+  chat(input: ModelChatInput): Promise<LLMResponse$1>;
+  chatStream(input: ModelChatInput): AsyncIterable<LLMStreamEvent$1>;
+}
+type AgentRuntimeSessionTypeCatalog = {
+  defaultType: string;
+  options: AgentRuntimeSessionTypeOption[];
+};
+interface IRuntimeRegistry {
+  registerProvider(provider: AgentRuntimeProviderRegistration): Disposer$1;
+  registerEntry(entry: AgentRuntimeEntry): Disposer$1;
+  listSessionTypes(params?: AgentRuntimeSessionTypeDescribeParams): Promise<AgentRuntimeSessionTypeCatalog>;
+}
+type McpToolCallInput = {
+  serverName: string;
+  toolName: string;
+  args: Record<string, unknown>;
+  signal?: AbortSignal;
+};
+interface IMcpRegistry {
+  registerServer(name: string, definition: McpServerDefinition$1): Promise<Disposer$1>;
+  listServers(): readonly McpServerRecord$1[];
+  listTools(filter?: McpCatalogFilter$1): readonly McpToolCatalogEntry$1[];
+  callTool(input: McpToolCallInput): Promise<unknown>;
+}
+interface IKernel {
+  readonly eventBus: EventBus$1;
+  readonly ingress: Ingress$1;
+  readonly tools: IToolRegistry;
+  readonly context: IContextRegistry;
+  readonly models: IModelRegistry;
+  readonly runtimes: IRuntimeRegistry;
+  readonly mcp: IMcpRegistry;
+}
+interface INextclawContributionRegistry {
+  register(contribution: Contribution): Disposer$1;
+  list(): readonly NextclawContributionDescriptor[];
+}
+interface INextclawRun {
+  readonly agentId: string;
+  readonly runId: string | null;
+  readonly sessionId: string;
+  readonly status: NextclawRunStatus;
+  events(): AsyncIterable<NcpEndpointEvent$1>;
+  result(): Promise<NextclawTaskResult>;
+  cancel(): Promise<void>;
+}
+interface INextclawSession {
+  readonly agentId: string;
+  readonly sessionId: string;
+  run(input: NextclawSessionRunInput): Promise<INextclawRun>;
+}
+interface INextclawAgentSessions {
+  create(input: NextclawSessionCreateInput): Promise<INextclawSession>;
+  resume(sessionId: string): Promise<INextclawSession>;
+}
+interface INextclawSessionRegistry {
+  resume(sessionId: string): Promise<INextclawSession>;
+}
+interface INextclawAgent {
+  readonly definition: NextclawAgentDefinition;
+  readonly id: string;
+  readonly sessions: INextclawAgentSessions;
+}
+interface INextclawAgentRegistry {
+  create(definition: NextclawAgentDefinition): Promise<INextclawAgent>;
+  get(agentId?: string): INextclawAgent;
+  list(): readonly NextclawAgentDefinition[];
+}
+interface INextclawHarness {
+  readonly agents: INextclawAgentRegistry;
+  readonly sessions: INextclawSessionRegistry;
+  readonly contributions: INextclawContributionRegistry;
+  start(): Promise<void>;
+  runTask(input: NextclawTaskInput): Promise<NextclawTaskResult>;
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region src/features/harness/managers/nextclaw-harness.manager.d.ts
+declare class NextclawHarness implements INextclawHarness {
+  private readonly options;
+  readonly agents: INextclawAgentRegistry;
+  readonly sessions: INextclawSessionRegistry;
+  readonly contributions: INextclawContributionRegistry;
+  private readonly contributionRegistry;
+  private readonly ownedRuns;
+  private state;
+  private kernel;
+  private startPromise;
+  constructor(options?: NextclawHarnessOptions);
+  start: () => Promise<void>;
+  runTask: (input: NextclawTaskInput) => Promise<NextclawTaskResult>;
+  dispose: () => Promise<void>;
+  private readonly requireKernel;
+  private startInternal;
+  private resolveTaskSession;
+  private readonly onRunCreated;
+  private readonly onRunSettled;
+  private disposeRuns;
+}
+//#endregion
+//#region src/features/harness/utils/nextclaw-task.utils.d.ts
+declare function runNextclawTask(input: NextclawTaskInput, options?: NextclawHarnessOptions): Promise<NextclawTaskResult>;
+//#endregion
 //#region src/services/panel-app-asset-token.service.d.ts
 type PanelAppAssetTokenClaims = {
   panelAppId: string;
@@ -2436,22 +3044,29 @@ declare function getServiceActionName(actionId: string, appId: string): string;
 //#region src/features/context-compaction/services/context-compaction-journal-recovery.service.d.ts
 declare class ContextCompactionJournalRecoveryService {
   private readonly pendingMessageIds;
+  private readonly pendingCheckpoints;
   private readonly recoveredTerminals;
-  seed: (messages: readonly NcpMessage[]) => void;
-  track: (event: NcpEndpointEvent) => void;
-  terminalize: (message: NcpMessage) => NcpMessage;
+  private readonly terminalMessages;
+  seed: (messages: readonly NcpMessage$1[]) => void;
+  track: (event: NcpEndpointEvent$1) => void;
+  private trackMessageSent;
+  private trackTerminalEvent;
+  terminalize: (message: NcpMessage$1) => NcpMessage$1;
   private readCheckpoint;
+  private readCheckpointByMessageId;
+  private readContinuationMessageId;
+  private readEventMessageId;
 }
 //#endregion
 //#region src/features/context-compaction/services/context-compaction-preflight.service.d.ts
 type ContextCompactionPreflightResult = {
   contextWindow: ContextWindowSnapshot;
-  sessionMessages: NcpMessage[];
-  timelineMessage: NcpMessage | null;
+  sessionMessages: NcpMessage$1[];
+  timelineMessage: NcpMessage$1 | null;
 };
 type ContextCompactionPreflightBeginResult = {
   contextWindow: ContextWindowSnapshot;
-  sessionMessages: NcpMessage[];
+  sessionMessages: NcpMessage$1[];
   pendingCompaction: ContextCompactionPendingWork | null;
 };
 type ContextCompactionTrigger = "automatic" | "manual";
@@ -2471,40 +3086,39 @@ type ContextCompactionPendingWork = {
   reservedContextTokens: number;
   snapshotFixedInputTokens: number;
   sessionId: string;
-  sessionMessages: NcpMessage[];
+  sessionMessages: NcpMessage$1[];
 };
 declare class ContextCompactionPreflightService {
   private readonly agentManager;
-  private readonly providerManager?;
   private readonly compactionService;
   private readonly contextWindowBudgetService;
-  constructor(agentManager: AgentManager, providerManager?: LlmProviderRuntime | undefined);
+  private readonly summaryGenerationService;
+  constructor(agentManager: AgentManager, providerManager?: LlmProviderRuntime);
   preview: (params: {
     completeInputBudget?: boolean;
     contextBlocks?: readonly string[];
     fixedInputTokens?: number;
     requestMetadata: Record<string, unknown>;
     sessionId: string;
-    sessionMessages: readonly NcpMessage[];
+    sessionMessages: readonly NcpMessage$1[];
     storedAgentId?: string;
     storedMetadata: Record<string, unknown>;
-    tools?: readonly NcpTool[];
+    tools?: readonly NcpTool$1[];
   }) => ContextWindowSnapshot | null;
   begin: (params: {
     contextBlocks?: readonly string[];
-    inputMessages: readonly NcpMessage[];
+    inputMessages: readonly NcpMessage$1[];
     model: string;
     phase?: ContextCompactionPhase;
     requestMetadata: Record<string, unknown>;
     sessionId: string;
-    sessionMessages: readonly NcpMessage[];
+    sessionMessages: readonly NcpMessage$1[];
     storedAgentId?: string;
     storedMetadata: Record<string, unknown>;
-    tools?: readonly NcpTool[];
+    tools?: readonly NcpTool$1[];
     trigger?: ContextCompactionTrigger;
   }) => ContextCompactionPreflightBeginResult;
   finish: (pending: ContextCompactionPendingWork, signal?: AbortSignal) => Promise<ContextCompactionPreflightResult>;
-  private generateSummary;
   private resolveCompactionProfile;
 }
 //#endregion
@@ -2516,33 +3130,33 @@ declare const CONTEXT_COMPACTION_PROJECTION_KIND = "compressed_context";
 declare const CONTEXT_COMPACTION_CONTINUATION_TEXT = "Continue the active run from the compressed working context. Do not repeat completed tool calls; proceed with the next required action.";
 declare const CONTEXT_COMPACTION_SYSTEM_PREAMBLE: string;
 type ContextCompactionTimelineCheckpoint = ContextCompactionCheckpoint;
-declare function readContextCompactionCheckpoint(message: NcpMessage): ContextCompactionCheckpoint | null;
+declare function readContextCompactionCheckpoint(message: NcpMessage$1): ContextCompactionCheckpoint | null;
 declare function createContextCompactionMessageId(): string;
 declare function buildContextCompactionTimelineNcpMessage(params: {
   messageId: string;
   sessionId: string;
   checkpoint: ContextCompactionTimelineCheckpoint;
-}): NcpMessage;
+}): NcpMessage$1;
 declare function isContextCompactionTimelineMessage(message: {
   metadata?: Record<string, unknown> | undefined;
 } | null | undefined): boolean;
 declare function isContextCompactionProjectionMessage(message: {
   metadata?: Record<string, unknown> | undefined;
 } | null | undefined): boolean;
-declare function readLatestContextCompactionCheckpoint(sessionMessages: readonly NcpMessage[]): ContextCompactionCheckpoint | null;
+declare function readLatestContextCompactionCheckpoint(sessionMessages: readonly NcpMessage$1[]): ContextCompactionCheckpoint | null;
 type ContextCompactionModelProjection = {
-  messages: NcpMessage[];
+  messages: NcpMessage$1[];
   stablePrefixMessageCount: number;
 };
 declare function buildContextCompactionModelProjection(params: {
   sessionId: string;
-  sessionMessages: readonly NcpMessage[];
+  sessionMessages: readonly NcpMessage$1[];
 }): ContextCompactionModelProjection;
-declare function readContextWindowEventSessionId(event: NcpEndpointEvent): string | null;
+declare function readContextWindowEventSessionId(event: NcpEndpointEvent$1): string | null;
 declare function isContextWindowSnapshot(value: unknown): value is Record<string, unknown>;
 declare function createContextWindowSignature(value: Record<string, unknown>): string;
-declare function shouldRefreshContextWindowDuringStream(event: NcpEndpointEvent): boolean;
-declare function shouldRefreshContextWindowImmediately(event: NcpEndpointEvent): boolean;
+declare function shouldRefreshContextWindowDuringStream(event: NcpEndpointEvent$1): boolean;
+declare function shouldRefreshContextWindowImmediately(event: NcpEndpointEvent$1): boolean;
 //#endregion
 //#region src/features/native-runtime/services/provider-manager-ncp-llm-api.service.d.ts
 declare class ProviderManagerNcpLLMApi implements NcpLLMApi {
@@ -2555,7 +3169,7 @@ declare class ProviderManagerNcpLLMApi implements NcpLLMApi {
 declare function createAssetTools(params: {
   assetStore: LocalAssetStore;
   contentBasePath?: string;
-}): NcpTool[];
+}): NcpTool$1[];
 //#endregion
 //#region src/features/native-runtime/utils/nextclaw-ncp-run-context.utils.d.ts
 type NextclawNcpResolvedAgentProfile = {
@@ -2617,56 +3231,13 @@ declare function resolveSessionChannelContext(params: {
   metadata: Record<string, unknown>;
 };
 //#endregion
-//#region src/features/extension-runtime/types/extension-runtime.types.d.ts
-type ExtensionProcessState = "stopped" | "starting" | "running" | "stopping" | "failed";
-type ExtensionLeaseReason = {
-  kind: "enabled-channel";
-  channelId: string;
-} | {
-  kind: "auth-session";
-  sessionId: string;
-  expiresAt: string;
-} | {
-  kind: "auth-handoff";
-  channelId: string;
-  expiresAt: string;
-} | {
-  kind: "request";
-  requestId: string;
-};
-type ExtensionRuntimeStatus = {
-  extensionId: string;
-  generation: string | null;
-  lastExit: {
-    at: string;
-    code: number | null;
-    expected: boolean;
-    signal: string | null;
-  } | null;
-  leaseReasons: ExtensionLeaseReason[];
-  memory: {
-    pssBytes: number | null;
-    rssBytes: number | null;
-  } | null;
-  pid: number | null;
-  startedAt: string | null;
-  state: ExtensionProcessState;
-  startupDurationMs: number | null;
-};
-//#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-message-adapter.utils.d.ts
-declare function toNcpMessages(sessionId: string, messages: SessionMessage[]): NcpMessage[];
+declare function toNcpMessages(sessionId: string, messages: SessionMessage[]): NcpMessage$1[];
 declare function resolveLegacyEventType(message: SessionMessage): string;
 //#endregion
 //#region src/utils/ui-content-params-injection.utils.d.ts
 declare function getUiContentParamsBootstrapScript(): string;
 declare function injectUiContentParamsBootstrap(html: string): string;
 //#endregion
-export { AUTOMATIC_UPDATE_CHECK_INTERVAL_MS, AccessLoginResult, AccessManager, AccessManagerOptions, AccessPasswordStatus, AccessPrincipal, AccessRole, AccessSessionRecord, AccessSessionState, AgentManager, AgentManagerOptions, AgentRunClient, type AgentRunReply, type AgentRunReplyOptions, AgentRunSession, type AgentRunStreamOptions, AgentRuntimeEntry, AgentRuntimeProviderRegistration, AgentRuntimeSessionRequestDispatcherOptions, AgentRuntimeSessionTypeDescribeParams, AgentRuntimeSessionTypeIcon, AgentRuntimeSessionTypeOption, AgentRuntimeSessionTypeProvider, AppDataDeleteResult, AppDataDiagnostic, AppDataEntry, AppDataError, AppDataErrorCode, AppDataLifecycle, AppDataList, AppDataManager, AppDataSource, AppPackageComponentKind, AppPackageComponentSource, AppPackageComponentView, AppPackageConflict, AppPackageError, AppPackageErrorCode, AppPackageHostTarget, AppPackageList, AppPackageManager, AppPackageOperationAction, AppPackageOperationInput, AppPackageOperationList, AppPackageOperationResult, AppPackageOperationStatus, AppPackageOperationView, AppPackageRuntimeHooks, AppPackageView, type AssetApi, AutomationManager, AutomationManagerOptions, type BuildAgentRunSendPayloadParams, BuiltinNarpRuntimeProviderService, CONTEXT_COMPACTION_CONTINUATION_TEXT, CONTEXT_COMPACTION_PROJECTION_KIND, CONTEXT_COMPACTION_PROJECTION_METADATA_KEY, CONTEXT_COMPACTION_SYSTEM_PREAMBLE, CONTEXT_COMPACTION_TIMELINE_KIND, ChannelManager, ChannelReplyRouterDispatchParams, CommandRegistry, ConfigManager, ConfigManagerOptions, ConfigManagerRuntimeHooks, ConfigMutationResult, ContextCompactionJournalRecoveryService, ContextCompactionModelProjection, ContextCompactionPreflightBeginResult, ContextCompactionPreflightResult, ContextCompactionPreflightService, ContextCompactionTimelineCheckpoint, ContextCompactionTrigger, CreateAgentRunSessionParams, CreateInboxDeliveryInput, CreateProjectInput, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DEFAULT_SERVICE_ACTION_RISK, DirectPromptDispatchParams, ExtensionLoadProgress, ExtensionLoadResult, ExtensionManager, type ExtensionRuntimeStatus, GatewayInboundLoopRuntime, GatewayInboundProcessor, InboxDeliveryError, InboxDeliveryErrorCode, InboxDeliveryManager, InboxDeliveryManagerOptions, InstallationKind, InstalledSkillDetail, InstalledSkillSummary, InstalledSkillsList, type LearningLoopRuntimeConfig, LlmProviderManager, LlmProviderRuntime, LlmUsageManager, LlmUsageManagerOptions, LlmUsageRecord, LlmUsageSnapshot, LlmUsageStats, LlmUsageStore, LlmUsageStoreOptions, LlmUsageSummary, LocalizedTextMap, MAX_INBOX_DELIVERY_CONTENT_LENGTH, McpManager, McpServiceAppRuntimeService, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NEXTCLAW_TIMELINE_KIND_METADATA_KEY, NcpAgentSessionJournalStore, NextclawKernel, NextclawKernelOptions, NextclawNcpResolvedAgentProfile, NextclawNcpResolvedRunContext, NextclawNcpRunContextResolveParams, PANEL_APP_AGENT_CAPABILITIES, PROJECT_TEMPLATE_IDS, PROVIDER_MODEL_CATALOG_REFRESH_INTERVAL_MS, PanelAppAgentCapability, PanelAppAgentGenerateObjectInput, PanelAppAgentGenerateObjectRequest, PanelAppAgentGenerateObjectResult, PanelAppAgentRunClient, PanelAppAgentSendPayload, PanelAppAgentSendRequest, PanelAppAgentSendResult, PanelAppAssetTokenService, PanelAppBridgeSession, PanelAppCapabilityGrant, PanelAppCapabilityGrantCaller, type PanelAppClientGrant, PanelAppContent, PanelAppDeleteResult, PanelAppEntry, PanelAppError, PanelAppErrorCode, PanelAppList, PanelAppManager, type PanelAppPreferencesUpdate, PreferenceEntry, PreferenceError, PreferenceErrorCode, PreferenceJsonValue, PreferenceManager, PreferenceManagerOptions, ProductActivityKind, ProductActivitySignal, ProductActivitySink, ProductActivitySource, ProjectError, ProjectErrorCode, ProjectManager, ProjectManagerOptions, ProjectRecord, ProjectTemplate, ProjectTemplateId, ProviderManagerNcpLLMApi, ProviderModelCatalogEntry, ProviderModelCatalogManager, ProviderModelCatalogSnapshot, ProviderModelsDiscoverInput, ResolvedAgentProfile, SERVICE_APP_MANIFEST_FILE_NAME, ServiceAction, ServiceActionCaller, ServiceActionGrant, ServiceActionGrantRequest, ServiceActionGrantState, ServiceActionInvokeRequest, ServiceActionInvokeResult, ServiceActionRisk, ServiceActionRuntimeState, ServiceAppDeleteResult, ServiceAppError, type ServiceAppErrorCode, ServiceAppList, ServiceAppManager, ServiceAppManifest, ServiceAppManifestAction, ServiceAppProtocol, ServiceAppRecord, ServiceAppRuntimeStatus, SessionContextCompactionError, SessionContextCompactionErrorCode, SessionContextCompactionManager, SessionContextCompactionResult, SessionManager, SessionManagerOptions, SessionMessageCursorError, SessionMessagePage, SessionModelTokenUsage, type SessionPendingInput, type SessionQueuedInput, SessionRequestManager, SessionRequestManagerOptions, SessionSettingsError, SessionSettingsPatch, type SessionSteerQueuedInputResult, SessionTokenUsageStatus, SessionTokenUsageSummary, SessionTokenUsageTotals, SkillFrontmatter, type SkillInfo, SkillManager, type SkillScope, SystemObjectReferenceError, SystemObjectReferenceErrorCode, SystemObjectReferenceManager, SystemObjectReferenceProvider, SystemObjectReferenceSnapshotSource, UnsignedUpdateManifest, UpdateBlockReason, UpdateHostKind, UpdateManifest, UpdateManifestReader, UpdateProgress, UpdateSnapshot, UpdateStatus, type WorkspaceServiceDataOwner, buildAgentRunSendPayload, buildContextCompactionModelProjection, buildContextCompactionTimelineNcpMessage, buildLlmUsageSummary, buildLocalizedTextMap, buildNextclawNcpRunContext, buildServiceActionId, createAgentRuntimeSessionRequestDispatcher, createAssetTools, createContextCompactionMessageId, createContextWindowSignature, createCronJobSystemObjectProvider, createInboxDeliverySystemObjectProvider, createLlmUsageRecord, describeAgentRuntimeSessionTypes, dispatchAgentRuntimeSessionRequest, dispatchChannelReplyRoute, dispatchPromptOverNcp, getAutomaticUpdateCheckDelay, getServiceActionName, getServiceAppManifestPath, getUiContentParamsBootstrapScript, getUnsignedUpdateManifest, hasLlmUsageTelemetry, injectUiContentParamsBootstrap, isAppDataError, isAppPackageError, isContextCompactionProjectionMessage, isContextCompactionTimelineMessage, isContextWindowSnapshot, isInboxDeliveryError, isPanelAppAgentCapability, isPanelAppError, isPreferenceError, isProjectError, isReplyCapableChannel, isServiceAppError, isSessionContextCompactionError, isSessionMessageCursorError, isSessionSettingsError, isSystemObjectReferenceError, listExtensionChannelIds, listServiceAppManifestActions, mergeServiceAppRuntimeActions, normalizeAgentRuntimeSessionTypeIcon, normalizeLlmUsageModel, normalizeOptionalString, parseServiceAppManifest, parseSkillFrontmatter, readContextCompactionCheckpoint, readContextWindowEventSessionId, readLatestContextCompactionCheckpoint, readLearningLoopRuntimeConfig, readMetadataModel, readMetadataThinking, readServiceAppManifest, resolveAgentRuntimeEntries, resolveAutomaticUpdateCheckIntervalMs, resolveChannelReplyRoute, resolveEffectiveModel, resolveLegacyEventType, resolveSessionChannelContext, runGatewayInboundLoop, sanitizeLlmUsage, serializeUnsignedUpdateManifest, shouldRefreshContextWindowDuringStream, shouldRefreshContextWindowImmediately, stripSkillFrontmatter, syncSessionThinkingPreference, toNcpMessages, waitForAgentRuntimeSessionReply };
+export { AUTOMATIC_UPDATE_CHECK_INTERVAL_MS, AccessLoginResult, AccessManager, AccessManagerOptions, AccessPasswordStatus, AccessPrincipal, AccessRole, AccessSessionRecord, AccessSessionState, AgentManager, AgentManagerOptions, AgentRunClient, type AgentRunReply, type AgentRunReplyOptions, AgentRunSession, type AgentRunStreamOptions, type AgentRuntimeEntry, type AgentRuntimeProviderRegistration, AgentRuntimeSessionRequestDispatcherOptions, type AgentRuntimeSessionTypeCatalog, type AgentRuntimeSessionTypeDescribeParams, AgentRuntimeSessionTypeIcon, type AgentRuntimeSessionTypeOption, AgentRuntimeSessionTypeProvider, AppDataDeleteResult, AppDataDiagnostic, AppDataEntry, AppDataError, AppDataErrorCode, AppDataLifecycle, AppDataList, AppDataManager, AppDataSource, type AppEventEmitOptions, type AppEventEnvelope, type AppEventHandler, type AppEventKey, AppPackageComponentKind, AppPackageComponentSource, AppPackageComponentView, AppPackageConflict, AppPackageError, AppPackageErrorCode, AppPackageHostTarget, AppPackageList, AppPackageManager, AppPackageOperationAction, AppPackageOperationInput, AppPackageOperationList, AppPackageOperationResult, AppPackageOperationStatus, AppPackageOperationView, AppPackageRuntimeHooks, AppPackageView, type AssetApi, AutomationManager, AutomationManagerOptions, BindContextInput, type BuildAgentRunSendPayloadParams, BuildContextTailInput, BuiltinNarpRuntimeProviderService, CONTEXT_COMPACTION_CONTINUATION_TEXT, CONTEXT_COMPACTION_PROJECTION_KIND, CONTEXT_COMPACTION_PROJECTION_METADATA_KEY, CONTEXT_COMPACTION_SYSTEM_PREAMBLE, CONTEXT_COMPACTION_TIMELINE_KIND, ChannelManager, ChannelReplyRouterDispatchParams, CommandRegistry, ConfigManager, ConfigManagerOptions, ConfigManagerRuntimeHooks, ConfigMutationResult, ContextBinding, type ContextBlock, ContextCompactionJournalRecoveryService, ContextCompactionModelProjection, ContextCompactionPreflightBeginResult, ContextCompactionPreflightResult, ContextCompactionPreflightService, ContextCompactionTimelineCheckpoint, ContextCompactionTrigger, type ContextProvider, type ContextProviderRequest, Contribution, CreateAgentRunSessionParams, CreateInboxDeliveryInput, CreateProjectInput, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DEFAULT_SERVICE_ACTION_RISK, DirectPromptDispatchExecution, DirectPromptDispatchParams, DirectPromptDispatchResult, type Disposer, EventAdmissionPolicy, EventBus, type EventBusOptions, EventDelivery, EventSubscription, EventSubscriptionBudget, ExtensionLoadProgress, ExtensionLoadResult, ExtensionManager, type ExtensionRuntimeStatus, GatewayInboundLoopRuntime, GatewayInboundProcessor, type IContextRegistry, type IKernel, type IMcpRegistry, type IModelRegistry, type INextclawAgent, type INextclawAgentRegistry, type INextclawAgentSessions, type INextclawContributionRegistry, type INextclawHarness, type INextclawRun, type INextclawSession, type INextclawSessionRegistry, type IRuntimeRegistry, type IToolRegistry, InboxDeliveryError, InboxDeliveryErrorCode, InboxDeliveryManager, InboxDeliveryManagerOptions, Ingress, type IngressContext, type IngressEnvelope, type IngressHandler, InstallationKind, InstalledSkillDetail, InstalledSkillSummary, InstalledSkillsList, JsonPointer, JsonValue, type Key, type LLMResponse, type LLMStreamEvent, type LearningLoopRuntimeConfig, LlmProviderManager, LlmProviderRuntime, LlmUsageManager, LlmUsageManagerOptions, LlmUsageRecord, LlmUsageSnapshot, LlmUsageStats, LlmUsageStore, LlmUsageStoreOptions, LlmUsageSummary, LocalizedTextMap, MAX_INBOX_DELIVERY_CONTENT_LENGTH, type McpCatalogFilter, McpManager, type McpServerDefinition, type McpServerRecord, McpServiceAppRuntimeService, type McpToolCallInput, type McpToolCatalogEntry, type ModelChatInput, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NEXTCLAW_TIMELINE_KIND_METADATA_KEY, NcpAgentSessionJournalStore, type NcpEndpointEvent, type NcpMessage, type NcpTool, type NextclawAgentDefinition, type NextclawContributionDescriptor, NextclawHarness, NextclawHarnessError, type NextclawHarnessErrorCode, type NextclawHarnessOptions, NextclawKernel, NextclawKernelOptions, NextclawNcpResolvedAgentProfile, NextclawNcpResolvedRunContext, NextclawNcpRunContextResolveParams, type NextclawRunStatus, type NextclawSessionCreateInput, type NextclawSessionRunInput, type NextclawTaskInput, type NextclawTaskResult, ObservationCapabilityDescriptor, ObservationContextTail, ObservationEvent, ObservationEventAdmissionDecision, ObservationExtensionRuntime, ObservationManager, ObservationManagerOptions, ObservationRef, ObservationRelationshipStatus, ObservationState, ObservationTarget, PANEL_APP_AGENT_CAPABILITIES, PROJECT_TEMPLATE_IDS, PROVIDER_MODEL_CATALOG_REFRESH_INTERVAL_MS, PanelAppAgentCapability, PanelAppAgentGenerateObjectInput, PanelAppAgentGenerateObjectRequest, PanelAppAgentGenerateObjectResult, PanelAppAgentRunClient, PanelAppAgentSendPayload, PanelAppAgentSendRequest, PanelAppAgentSendResult, PanelAppAssetTokenService, PanelAppBridgeSession, PanelAppCapabilityGrant, PanelAppCapabilityGrantCaller, type PanelAppClientGrant, PanelAppContent, PanelAppDeleteResult, PanelAppEntry, PanelAppError, PanelAppErrorCode, PanelAppList, PanelAppManager, type PanelAppPreferencesUpdate, PreferenceEntry, PreferenceError, PreferenceErrorCode, PreferenceJsonValue, PreferenceManager, PreferenceManagerOptions, ProductActivityKind, ProductActivitySignal, ProductActivitySink, ProductActivitySource, ProjectError, ProjectErrorCode, ProjectManager, ProjectManagerOptions, ProjectRecord, ProjectTemplate, ProjectTemplateId, type ProviderCatalogPlugin, ProviderManagerNcpLLMApi, ProviderModelCatalogEntry, ProviderModelCatalogManager, ProviderModelCatalogSnapshot, ProviderModelsDiscoverInput, type ProviderSpec, ResolvedAgentProfile, SERVICE_APP_MANIFEST_FILE_NAME, ServiceAction, ServiceActionCaller, ServiceActionGrant, ServiceActionGrantRequest, ServiceActionGrantState, ServiceActionInvokeRequest, ServiceActionInvokeResult, ServiceActionRisk, ServiceActionRuntimeState, ServiceAppDeleteResult, ServiceAppError, type ServiceAppErrorCode, ServiceAppList, ServiceAppManager, ServiceAppManifest, ServiceAppManifestAction, ServiceAppProtocol, ServiceAppRecord, ServiceAppRuntimeStatus, SessionContextCompactionError, SessionContextCompactionErrorCode, SessionContextCompactionManager, SessionContextCompactionResult, SessionManager, SessionManagerOptions, SessionMessageCursorError, SessionMessagePage, SessionModelTokenUsage, type SessionPendingInput, type SessionQueuedInput, SessionRequestManager, SessionRequestManagerOptions, SessionSettingsError, SessionSettingsPatch, type SessionSteerQueuedInputResult, SessionTokenUsageStatus, SessionTokenUsageSummary, SessionTokenUsageTotals, SkillFrontmatter, type SkillInfo, SkillManager, type SkillScope, SubscribeEventsInput, SystemObjectReferenceError, SystemObjectReferenceErrorCode, SystemObjectReferenceManager, SystemObjectReferenceProvider, SystemObjectReferenceSnapshotSource, type TypedKey, TypedPredicate, UnsignedUpdateManifest, type Unsubscribe, UpdateBlockReason, UpdateHostKind, UpdateManifest, UpdateManifestReader, UpdateProgress, UpdateSnapshot, UpdateStatus, type WorkspaceServiceDataOwner, assertObservationJsonValue, assertObservationPredicate, buildAgentRunSendPayload, buildContextCompactionModelProjection, buildContextCompactionTimelineNcpMessage, buildLlmUsageSummary, buildLocalizedTextMap, buildNextclawNcpRunContext, buildObservationEventModelMessage, buildServiceActionId, createAgentRuntimeSessionRequestDispatcher, createAssetTools, createContextCompactionMessageId, createContextWindowSignature, createCronJobSystemObjectProvider, createInboxDeliverySystemObjectProvider, createLlmUsageRecord, createTypedKey, describeAgentRuntimeSessionTypes, dispatchAgentRuntimeSessionRequest, dispatchChannelReplyRoute, dispatchPromptOverNcp, dispatchPromptOverNcpResult, evaluateObservationEventAdmission, eventKeys, getAutomaticUpdateCheckDelay, getServiceActionName, getServiceAppManifestPath, getUiContentParamsBootstrapScript, getUnsignedUpdateManifest, hasLlmUsageTelemetry, ingressKeys, injectUiContentParamsBootstrap, isAppDataError, isAppPackageError, isContextCompactionProjectionMessage, isContextCompactionTimelineMessage, isContextWindowSnapshot, isInboxDeliveryError, isPanelAppAgentCapability, isPanelAppError, isPreferenceError, isProjectError, isReplyCapableChannel, isServiceAppError, isSessionContextCompactionError, isSessionMessageCursorError, isSessionSettingsError, isSystemObjectReferenceError, listExtensionChannelIds, listServiceAppManifestActions, matchesObservationPredicate, mergeServiceAppRuntimeActions, normalizeAgentRuntimeSessionTypeIcon, normalizeLlmUsageModel, normalizeOptionalString, parseObservationDuration, parseServiceAppManifest, parseSkillFrontmatter, readContextCompactionCheckpoint, readContextWindowEventSessionId, readJsonPointer, readLatestContextCompactionCheckpoint, readLearningLoopRuntimeConfig, readMetadataModel, readMetadataThinking, readServiceAppManifest, resolveAgentRuntimeEntries, resolveAutomaticUpdateCheckIntervalMs, resolveChannelReplyRoute, resolveEffectiveModel, resolveLegacyEventType, resolveSessionChannelContext, runGatewayInboundLoop, runNextclawTask, sanitizeLlmUsage, serializeContextTail, serializeUnsignedUpdateManifest, shouldRefreshContextWindowDuringStream, shouldRefreshContextWindowImmediately, startPromptOverNcpExecution, stripSkillFrontmatter, syncSessionThinkingPreference, toBoundedJson, toNcpMessages, waitForAgentRuntimeSessionReply };
 //# sourceMappingURL=index.d.ts.map