@nextclaw/kernel 0.1.6 → 0.1.8

package/dist/index.d.ts

@@ -140,11 +140,6 @@ declare class ExtensionManager {
   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
@@ -888,26 +883,19 @@ declare class NextclawNcpToolRegistry implements NcpToolRegistry {
   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;
   getConfig: () => Config;
-  resolveMessageToolHints?: MessageToolHintsResolver;
   assetStore?: LocalAssetStore | null;
 };
 declare class NextclawNcpContextBuilder implements NcpContextBuilder {
@@ -975,4 +963,4 @@ 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 };
+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, readLearningLoopRuntimeConfig, resolveAgentHandoffDepth, resolveAgentRuntimeEntries, resolveChannelReplyRoute, resolveLegacyEventType, runGatewayInboundLoop, runPromptOverNcp, sanitizeLlmUsage, serializeUnsignedUpdateManifest, streamPromptOverNcp, toNcpMessages, waitForAgentRuntimeSessionReply };

package/dist/index.js

@@ -2,7 +2,7 @@ import { n as getUnsignedUpdateManifest, r as serializeUnsignedUpdateManifest, t
 import { AgentRouteResolver, CONTEXT_COMPACTION_METADATA_KEY, ChannelManager, ChannelManager as ChannelManager$1, CommandRegistry, ContextBuilder, ContextCompactionService, ContextWindowBudgetService, CronService, CronTool, DEFAULT_SESSION_SEARCH_LIMIT, DisposableStore, EditFileTool, ExecTool, ExtensionToolAdapter, GatewayTool, InputBudgetPruner, LLMProvider, ListDirTool, LiteLLMProvider, MAX_SESSION_SEARCH_LIMIT, MemoryGetTool, MemorySearchTool, MessageBus, MessageTool, ProviderRegistry, ReadFileTool, RequestedSkillsMetadataReader, SessionManager, SessionRequestManager, SessionSearchManager, SessionsHistoryTool, SessionsListTool, Tool, ToolRegistry, WebFetchTool, WebSearchTool, WriteFileTool, buildCompressingCompactionCheckpoint, buildContextWindowSnapshot, buildMinimalSystemExecutionPrompt, buildReloadPlan, buildToolCatalogEntries, createAssistantStreamDeltaControlMessage, createAssistantStreamResetControlMessage, createToolExecutionContext, createTypingStopControlMessage, diffConfigPaths, ensureDir, expandHome, findEffectiveAgentProfile, getConfigPath, getDataDir, getSessionsPath, getWorkspacePath, loadConfig, parseAgentScopedSessionKey, parseThinkingLevel, readCompressedContextCompactionCheckpoint, readParentSessionId, readSessionProjectRoot, resolveConfigSecrets, resolveDefaultAgentProfileId, resolveProviderRuntime, resolveSessionWorkspacePath, resolveThinkingLevel, toDisposable } from "@nextclaw/core";
 import { EventBus, Ingress, createAppEventKey, createTypedKey, eventKeys } from "@nextclaw/shared";
 import { DefaultNcpAgentRuntime, LocalAssetStore, buildAssetContentPath, buildNcpUserContent, buildOpenAiFunctionTool } from "@nextclaw/ncp-agent-runtime";
-import { NcpEventType, readAssistantReasoningNormalizationMode, readAssistantReasoningNormalizationModeFromMetadata, sanitizeAssistantReplyTags, writeAssistantReasoningNormalizationModeToMetadata } from "@nextclaw/ncp";
+import { NcpEventType, consumeNcpRunHandle, createNcpRunHandle, readAssistantReasoningNormalizationMode, readAssistantReasoningNormalizationModeFromMetadata, sanitizeAssistantReplyTags, writeAssistantReasoningNormalizationModeToMetadata } from "@nextclaw/ncp";
 import { DefaultNcpAgentBackend, DefaultNcpAgentConversationStateManager, createAgentClientFromServer } from "@nextclaw/ncp-toolkit";
 import { basename, delimiter, dirname, join, resolve } from "node:path";
 import { access, appendFile, mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
@@ -13,7 +13,7 @@ import { StdioRuntimeConfigResolver, StdioRuntimeNcpAgentRuntime, probeStdioRunt
 import { buildHermesAcpBridgeLaunchEnv, isHermesAcpRuntimeConfig } from "@nextclaw/nextclaw-hermes-acp-bridge";
 import { McpRegistryService, McpServerLifecycleManager } from "@nextclaw/mcp";
 import { McpNcpToolRegistryAdapter } from "@nextclaw/ncp-mcp";
-import { getPluginChannelBindings, getPluginUiMetadataFromRegistry, mergePluginConfigView, resolvePluginChannelMessageToolHints, toPluginConfigView } from "@nextclaw/openclaw-compat";
+import { getPluginChannelBindings, getPluginUiMetadataFromRegistry, mergePluginConfigView, toPluginConfigView } from "@nextclaw/openclaw-compat";
 //#region src/managers/agent.manager.ts
 var AgentManager = class {
 	listAgents = () => {
@@ -2611,7 +2611,7 @@ var NextclawNcpToolRegistry = class {
 	registerMessagingTools = (context) => {
 		const { channel, chatId, metadata } = context;
 		const accountId = readMetadataAccountId(metadata, {});
-		const messageTool = new MessageTool((message) => this.options.bus.publishOutbound(message));
+		const messageTool = new MessageTool((message) => this.options.bus.publishOutbound(message), { resolveChannels: this.resolveMessageChannels });
 		messageTool.setContext(channel, chatId, accountId ?? null);
 		this.registerTool(messageTool);
 		if (this.options.cronService) {
@@ -2620,6 +2620,10 @@ var NextclawNcpToolRegistry = class {
 			this.registerTool(cronTool);
 		}
 	};
+	resolveMessageChannels = () => {
+		const channels = (this.options.getExtensionRegistry?.())?.channels ?? [];
+		return [...new Set(channels.map((registration) => registration.channel.id.trim()).filter(Boolean))].sort();
+	};
 	registerExtensionTools = (context) => {
 		const extensionRegistry = this.options.getExtensionRegistry?.();
 		if (!extensionRegistry || extensionRegistry.tools.length === 0) return;
@@ -2658,9 +2662,6 @@ function resolveAgentHandoffDepth(metadata) {
 	if (!Number.isFinite(rawDepth) || rawDepth < 0) return 0;
 	return Math.trunc(rawDepth);
 }
-function readAccountIdForHints(metadata, sessionMetadata) {
-	return readMetadataAccountId(metadata, sessionMetadata);
-}
 //#endregion
 //#region src/features/native-runtime/services/nextclaw-ncp-context-builder.service.ts
 const TIME_HINT_TRIGGER_PATTERNS = [/\b(now|right now|current time|what time|today|tonight|tomorrow|yesterday|this morning|this afternoon|this evening|date)\b/i, /(现在|此刻|当前时间|现在几点|几点了|今天|今晚|今早|今晨|明天|昨天|日期)/];
@@ -2820,7 +2821,6 @@ var NextclawNcpContextBuilder = class {
 			workspace: effectiveWorkspace
 		});
 		return {
-			accountId: readAccountIdForHints(requestMetadata, session.metadata),
 			channel,
 			chatId,
 			config,
@@ -2837,13 +2837,7 @@ var NextclawNcpContextBuilder = class {
 		};
 	};
 	buildModelMessages = (input, _options, runContext) => {
-		const { accountId, channel, chatId, config, currentTurn, effectiveModel, effectiveWorkspace, profile, requestedSkills, runtimeThinking, session } = runContext;
-		const messageToolHints = this.options.resolveMessageToolHints?.({
-			sessionKey: input.sessionId,
-			channel,
-			chatId,
-			accountId: accountId ?? null
-		});
+		const { channel, chatId, config, currentTurn, effectiveModel, effectiveWorkspace, profile, requestedSkills, runtimeThinking, session } = runContext;
 		const toolDefinitions = this.options.toolRegistry.getToolDefinitions();
 		const additionalSystemSections = [buildSessionOrchestrationSection(), buildMinimalSystemExecutionPrompt(effectiveModel)].filter(Boolean);
 		const contextBuilder = new ContextBuilder(effectiveWorkspace, config.agents.context, {
@@ -2865,7 +2859,6 @@ var NextclawNcpContextBuilder = class {
 			sessionKey: input.sessionId,
 			thinkingLevel: runtimeThinking,
 			skillNames: requestedSkills.selectors,
-			messageToolHints,
 			availableTools: buildToolCatalogEntries(toolDefinitions),
 			additionalSystemSections
 		});
@@ -3034,11 +3027,6 @@ var NativeAgentRuntimeFactory = class {
 				sessionManager: this.options.sessions,
 				toolRegistry,
 				getConfig: this.options.configManager.loadConfig,
-				resolveMessageToolHints: ({ channel, accountId }) => this.options.extensions.resolveMessageToolHints({
-					channel,
-					config: this.options.configManager.loadConfig(),
-					accountId
-				}),
 				assetStore: this.options.assetStore
 			}),
 			llmApi: new ProviderManagerNcpLLMApi(this.observedProviderManager),
@@ -3087,11 +3075,6 @@ var NativeAgentRuntimeFactory = class {
 			sessionManager: this.options.sessions,
 			toolRegistry: this.createToolRegistry(this.options.providerManager),
 			getConfig: this.options.configManager.loadConfig,
-			resolveMessageToolHints: ({ channel, accountId }) => this.options.extensions.resolveMessageToolHints({
-				channel,
-				config: this.options.configManager.loadConfig(),
-				accountId
-			}),
 			assetStore: this.options.assetStore
 		}).prepare(input).tools;
 	};
@@ -3383,35 +3366,39 @@ var AgentRuntimeManager = class {
 			}
 		};
 	};
-	createMaterializingAgentClientEndpoint = (backend) => ({
-		get manifest() {
-			return backend.manifest;
-		},
-		start: backend.start,
-		stop: backend.stop,
-		subscribe: backend.subscribe,
-		stream: async (payload) => {
-			await consumeAgentEvents(backend.stream(payload));
-		},
-		abort: backend.abort,
-		send: async (envelope) => {
-			await consumeAgentEvents(backend.send(this.materializeAgentSendEnvelope(envelope)));
-		},
-		emit: async (event) => {
-			switch (event.type) {
-				case NcpEventType.MessageRequest:
-					await consumeAgentEvents(backend.send(this.materializeAgentSendEnvelope(event.payload)));
-					return;
-				case NcpEventType.MessageStreamRequest:
-					await consumeAgentEvents(backend.stream(event.payload));
-					return;
-				case NcpEventType.MessageAbort:
-					await backend.abort(event.payload);
-					return;
-				default: await backend.emit(event);
+	createMaterializingAgentClientEndpoint = (backend) => {
+		const send = async (envelope) => {
+			const requestEnvelope = this.materializeAgentSendEnvelope(envelope);
+			return await consumeNcpRunHandle(backend.send(requestEnvelope), createNcpRunHandle(requestEnvelope));
+		};
+		return {
+			get manifest() {
+				return backend.manifest;
+			},
+			start: backend.start,
+			stop: backend.stop,
+			subscribe: backend.subscribe,
+			stream: async (payload) => {
+				await consumeAgentEvents(backend.stream(payload));
+			},
+			abort: backend.abort,
+			send,
+			emit: async (event) => {
+				switch (event.type) {
+					case NcpEventType.MessageRequest:
+						await send(event.payload);
+						return;
+					case NcpEventType.MessageStreamRequest:
+						await consumeAgentEvents(backend.stream(event.payload));
+						return;
+					case NcpEventType.MessageAbort:
+						await backend.abort(event.payload);
+						return;
+					default: await backend.emit(event);
+				}
 			}
-		}
-	});
+		};
+	};
 	warmDerivedCapabilities = async () => {
 		this.assertNotDisposed();
 		this.warmupPromise ??= this.runDerivedCapabilityWarmup();
@@ -3665,15 +3652,6 @@ var ExtensionManager = class {
 	getUiMetadata = () => this.uiMetadata;
 	toConfigView = (config) => toPluginConfigView(config, this.channelBindings);
 	mergeConfigView = (current, nextConfigView) => mergePluginConfigView(current, nextConfigView, this.channelBindings);
-	resolveMessageToolHints = (params) => {
-		if (!this.pluginRegistry) return [];
-		return resolvePluginChannelMessageToolHints({
-			registry: this.pluginRegistry,
-			channel: params.channel,
-			cfg: params.config,
-			accountId: params.accountId
-		});
-	};
 };
 //#endregion
 //#region src/configs/ncp-lifecycle-event.config.ts
@@ -4285,8 +4263,8 @@ var NcpSessionApiService = class {
 		if (normalizedSessionId && this.options.ncpAgentSessionStore) {
 			const existing = await this.options.ncpAgentSessionStore.getSession(normalizedSessionId);
 			if (existing) {
-				await this.options.ncpAgentSessionStore.replaceSession({
-					...existing,
+				await this.options.ncpAgentSessionStore.updateSessionMetadata({
+					sessionId: normalizedSessionId,
 					metadata: buildUpdatedMetadata({
 						existingMetadata: existing.metadata,
 						patch
@@ -4349,21 +4327,6 @@ var NcpAgentLegacySessionStore = class {
 			metadata: structuredClone(session.metadata)
 		};
 	};
-	getSessionSummary = (sessionId) => {
-		const session = this.getSession(sessionId);
-		if (!session) return null;
-		const lastMessageAt = session.messages.at(-1)?.timestamp;
-		return {
-			sessionId: session.sessionId,
-			...session.agentId ? { agentId: session.agentId } : {},
-			messageCount: session.messages.length,
-			createdAt: session.createdAt,
-			updatedAt: session.updatedAt,
-			...lastMessageAt ? { lastMessageAt } : {},
-			status: "idle",
-			metadata: session.metadata
-		};
-	};
 	listSessionMessages = (sessionId) => this.getSession(sessionId)?.messages ?? [];
 	listSessionSummaries = () => this.sessionManager.listSessions().map((record) => ({
 		sessionId: record.key,
@@ -4376,7 +4339,16 @@ var NcpAgentLegacySessionStore = class {
 		metadata: structuredClone(record.metadata)
 	}));
 	saveSession = (sessionRecord) => this.persistSession(sessionRecord, true);
-	replaceSession = (sessionRecord) => this.persistSession(sessionRecord, false);
+	updateSessionMetadata = async (params) => {
+		const { metadata, sessionId, updatedAt } = params;
+		const session = this.sessionManager.getIfExists(sessionId);
+		if (!session) return false;
+		session.metadata = structuredClone(metadata);
+		session.updatedAt = new Date(ensureIsoTimestamp(updatedAt, session.updatedAt.toISOString()));
+		this.sessionManager.save(session);
+		this.options.onSessionUpdated?.(sessionId);
+		return true;
+	};
 	deleteSession = (sessionId) => {
 		const existing = this.getSession(sessionId);
 		if (!existing) return null;
@@ -4422,14 +4394,13 @@ var NcpAgentSessionStoreAdapter = class {
 			const { event, session } = params;
 			if (!await journalStore.hasSession(session.sessionId)) {
 				const legacySession = this.legacyStore.getSession(session.sessionId);
-				if (legacySession) await journalStore.replaceSession(legacySession);
+				if (legacySession) await journalStore.materializeSession(legacySession);
 			}
 			await journalStore.appendSessionEvent(params);
 			if (isSessionSummaryRefreshEvent(event)) this.options.onSessionUpdated?.(session.sessionId);
 		};
 	}
 	getSession = async (sessionId) => await this.options.journalStore?.getSession(sessionId) ?? this.legacyStore.getSession(sessionId);
-	getSessionSummary = async (sessionId) => await this.options.journalStore?.getSessionSummary(sessionId) ?? this.legacyStore.getSessionSummary(sessionId);
 	listSessionMessages = async (sessionId) => {
 		const journalStore = this.options.journalStore;
 		return journalStore && await journalStore.hasSession(sessionId) ? await journalStore.listSessionMessages(sessionId) : this.legacyStore.listSessionMessages(sessionId);
@@ -4456,20 +4427,20 @@ var NcpAgentSessionStoreAdapter = class {
 	saveSession = async (sessionRecord) => {
 		const journalStore = this.options.journalStore;
 		if (journalStore && await journalStore.hasSession(sessionRecord.sessionId)) {
-			await journalStore.replaceSession(sessionRecord);
+			await journalStore.materializeSession(sessionRecord);
 			this.options.onSessionUpdated?.(sessionRecord.sessionId);
 			return;
 		}
 		await this.legacyStore.saveSession(sessionRecord);
 	};
-	replaceSession = async (sessionRecord) => {
+	updateSessionMetadata = async (params) => {
 		const journalStore = this.options.journalStore;
-		if (journalStore && await journalStore.hasSession(sessionRecord.sessionId)) {
-			await journalStore.replaceSession(sessionRecord);
-			this.options.onSessionUpdated?.(sessionRecord.sessionId);
-			return;
+		if (journalStore && await journalStore.hasSession(params.sessionId)) {
+			const updated = await journalStore.updateSessionMetadata(params);
+			if (updated) this.options.onSessionUpdated?.(params.sessionId);
+			return updated;
 		}
-		await this.legacyStore.replaceSession(sessionRecord);
+		return this.legacyStore.updateSessionMetadata(params);
 	};
 	deleteSession = async (sessionId) => {
 		const journalSession = await this.options.journalStore?.deleteSession(sessionId);
@@ -4493,6 +4464,7 @@ function isSessionSummaryRefreshEvent(event) {
 }
 const NCP_AGENT_SESSION_JOURNAL_INDEX_FILE = ".ncp-agent-session-index.json";
 const AUTO_SESSION_LABEL_MAX_LENGTH = 64;
+const NCP_AGENT_SESSION_SNAPSHOT_MESSAGE_EVENT_TYPE = "session.snapshot.message";
 function normalizeNcpSessionId(sessionId) {
 	return sessionId.trim();
 }
@@ -4500,15 +4472,13 @@ function safeNcpSessionFilename(value) {
 	return value.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function normalizeNcpAgentId(agentId) {
-	const normalized = agentId?.trim().toLowerCase();
-	return normalized ? normalized : void 0;
+	return agentId?.trim().toLowerCase() || void 0;
 }
 function isRecord$1(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function toIsoString(value, fallback) {
-	if (typeof value !== "string") return fallback;
-	const parsed = Date.parse(value);
+	const parsed = typeof value === "string" ? Date.parse(value) : NaN;
 	return Number.isFinite(parsed) ? new Date(parsed).toISOString() : fallback;
 }
 function createNcpAgentSessionSummary(record) {
@@ -4543,9 +4513,9 @@ function upsertNcpAgentSessionSummaryEvent(params) {
 		...current?.metadata ? structuredClone(current.metadata) : {},
 		...session.metadata ? structuredClone(session.metadata) : {}
 	};
-	const label = readOptionalText(metadata.label) ?? readSummaryLabelFromEvent(event);
-	if (label) metadata.label = truncateLabel(label);
 	const eventMessage = readMessageFromSummaryEvent(event);
+	const label = readOptionalText(metadata.label) ?? (eventMessage?.role === "user" ? resolveAutoSessionLabel([eventMessage]) : null);
+	if (label) metadata.label = truncateLabel(label);
 	const messageCount = current ? current.messageCount + (eventMessage ? 1 : 0) : eventMessage ? 1 : 0;
 	const lastMessageAt = readMessageTimestamp(eventMessage) ?? current?.lastMessageAt;
 	return {
@@ -4561,24 +4531,32 @@ function upsertNcpAgentSessionSummaryEvent(params) {
 }
 async function replayNcpAgentSessionEvents(events) {
 	const stateManager = new DefaultNcpAgentConversationStateManager();
-	for (const event of events) await stateManager.dispatch(event.type === NcpEventType.MessageCompleted ? createCompletedMessageEvent(event) : structuredClone(event));
+	for (const event of events) await stateManager.dispatch(createReplayEvent(event));
 	const snapshot = stateManager.getSnapshot();
 	return [...snapshot.messages.map((message) => structuredClone(message)), ...snapshot.streamingMessage ? [structuredClone(snapshot.streamingMessage)] : []];
 }
+function createReplayEvent(event) {
+	const replayEvent = structuredClone(event);
+	const replayMessage = readMessageFromSummaryEvent(replayEvent);
+	if (replayMessage?.role === "assistant" && (replayMessage.status === "pending" || replayMessage.status === "streaming")) replayMessage.status = "final";
+	if (replayEvent.type === "session.snapshot.message" || replayEvent.type === NcpEventType.MessageCompleted) return {
+		type: NcpEventType.MessageSent,
+		payload: replayEvent.payload
+	};
+	return replayEvent;
+}
 function readNcpSessionSummaryActivityAt(summary) {
 	return summary.lastMessageAt ?? summary.createdAt ?? summary.updatedAt;
 }
 function readMessageTimestamp(message) {
-	return typeof message?.timestamp === "string" && Number.isFinite(Date.parse(message.timestamp)) ? new Date(message.timestamp).toISOString() : void 0;
+	return toIsoString(message?.timestamp, "") || void 0;
 }
 function truncateLabel(value) {
 	const chars = Array.from(value);
 	return chars.length <= AUTO_SESSION_LABEL_MAX_LENGTH ? value : `${chars.slice(0, AUTO_SESSION_LABEL_MAX_LENGTH).join("")}...`;
 }
 function readOptionalText(value) {
-	if (typeof value !== "string") return null;
-	const trimmed = value.trim();
-	return trimmed ? trimmed : null;
+	return (typeof value === "string" ? value.trim() : "") || null;
 }
 function resolveAutoSessionLabel(messages) {
 	for (const message of messages) {
@@ -4594,34 +4572,139 @@ function readMessageFromSummaryEvent(event) {
 	switch (event.type) {
 		case NcpEventType.MessageSent: return event.payload.message;
 		case NcpEventType.MessageCompleted: return event.payload.message;
+		case NCP_AGENT_SESSION_SNAPSHOT_MESSAGE_EVENT_TYPE: return event.payload.message;
 		default: return;
 	}
 }
-function readSummaryLabelFromEvent(event) {
-	const message = readMessageFromSummaryEvent(event);
-	if (message?.role !== "user") return null;
-	return resolveAutoSessionLabel([message]);
-}
-function createCompletedMessageEvent(event) {
-	return {
-		type: NcpEventType.MessageSent,
-		payload: {
-			sessionId: event.payload.sessionId,
-			message: structuredClone(event.payload.message),
-			...event.payload.correlationId ? { correlationId: event.payload.correlationId } : {},
-			metadata: event.payload.metadata
+//#endregion
+//#region src/stores/ncp-agent-session-metadata.store.ts
+var NcpAgentSessionMetadataStore = class {
+	constructor(journalDir) {
+		this.journalDir = journalDir;
+	}
+	write = async (record) => {
+		await mkdir(this.journalDir, { recursive: true });
+		await writeFile(this.metadataPath(record.sessionId), `${this.serializeMetadata(record)}\n`, "utf-8");
+	};
+	read = async (sessionId, fallback) => {
+		try {
+			const parsed = JSON.parse(await readFile(this.metadataPath(sessionId), "utf-8"));
+			if (!isRecord$1(parsed) || parsed._type !== "metadata") return fallback;
+			const createdAt = toIsoString(parsed.created_at, fallback.createdAt);
+			const agentId = normalizeNcpAgentId(typeof parsed.agent_id === "string" ? parsed.agent_id : void 0);
+			return {
+				metadata: isRecord$1(parsed.metadata) ? structuredClone(parsed.metadata) : {},
+				...agentId ? { agentId } : {},
+				createdAt,
+				updatedAt: toIsoString(parsed.updated_at, createdAt)
+			};
+		} catch {
+			return fallback;
 		}
 	};
-}
+	delete = async (sessionId) => {
+		try {
+			await unlink(this.metadataPath(sessionId));
+		} catch {}
+	};
+	serializeMetadata = (record) => {
+		const serialized = JSON.stringify(createNcpAgentSessionJournalMetadataEntry(record));
+		if (!serialized) throw new Error("ncp agent session metadata serialization produced empty output");
+		return serialized;
+	};
+	metadataPath = (sessionId) => {
+		return join(this.journalDir, `${safeNcpSessionFilename(sessionId.replace(/:/g, "_"))}.metadata.json`);
+	};
+};
+//#endregion
+//#region src/stores/ncp-agent-session-summary-index.store.ts
+var NcpAgentSessionSummaryIndexStore = class {
+	summaryIndex = null;
+	constructor(journalDir, loadSession) {
+		this.journalDir = journalDir;
+		this.loadSession = loadSession;
+	}
+	has = async (sessionId) => (await this.load()).has(sessionId);
+	list = async () => {
+		return [...(await this.load()).values()].map((summary) => structuredClone(summary)).sort((left, right) => readNcpSessionSummaryActivityAt(right).localeCompare(readNcpSessionSummaryActivityAt(left)));
+	};
+	upsert = async (summary) => {
+		(await this.load()).set(summary.sessionId, structuredClone(summary));
+		await this.persist();
+	};
+	upsertForEvent = async (params) => {
+		const { event, session, updatedAt } = params;
+		const index = await this.load();
+		const summary = upsertNcpAgentSessionSummaryEvent({
+			current: index.get(session.sessionId),
+			session,
+			event,
+			updatedAt
+		});
+		index.set(summary.sessionId, summary);
+		await this.persist();
+	};
+	remove = async (sessionId) => {
+		(await this.load()).delete(sessionId);
+		await this.persist();
+	};
+	load = async () => {
+		if (this.summaryIndex) return this.summaryIndex;
+		try {
+			const parsed = JSON.parse(await readFile(this.indexPath(), "utf-8"));
+			if (parsed.version === 1 && Array.isArray(parsed.records)) {
+				this.summaryIndex = new Map(parsed.records.map((record) => [record.sessionId, structuredClone(record)]));
+				return this.summaryIndex;
+			}
+		} catch {}
+		this.summaryIndex = await this.rebuild();
+		await this.persist();
+		return this.summaryIndex;
+	};
+	rebuild = async () => {
+		const records = /* @__PURE__ */ new Map();
+		let entries = [];
+		try {
+			entries = await readdir(this.journalDir);
+		} catch {
+			return records;
+		}
+		for (const entry of entries) {
+			if (!entry.endsWith(".jsonl")) continue;
+			const sessionId = entry.replace(/\.jsonl$/, "").replace(/_/g, ":");
+			const loaded = await this.loadSession(sessionId);
+			if (loaded) records.set(sessionId, createNcpAgentSessionSummary(loaded.record));
+		}
+		return records;
+	};
+	persist = async () => {
+		const records = [...this.summaryIndex?.values() ?? []].map((summary) => structuredClone(summary)).sort((left, right) => readNcpSessionSummaryActivityAt(right).localeCompare(readNcpSessionSummaryActivityAt(left)));
+		await mkdir(this.journalDir, { recursive: true });
+		await writeFile(this.indexPath(), `${JSON.stringify({
+			version: 1,
+			records
+		})}\n`, "utf-8");
+	};
+	indexPath = () => resolve(this.journalDir, NCP_AGENT_SESSION_JOURNAL_INDEX_FILE);
+};
 //#endregion
 //#region src/stores/ncp-agent-session-journal.store.ts
+function serializeJournalEntry(entry) {
+	const serialized = JSON.stringify(entry);
+	if (!serialized) throw new Error("ncp agent session journal entry serialization produced empty output");
+	if (!isRecord$1(JSON.parse(serialized))) throw new Error("ncp agent session journal entry serialization produced a non-object entry");
+	return serialized;
+}
 var NcpAgentSessionJournalStore = class {
 	sessions = /* @__PURE__ */ new Map();
 	nextSeqBySession = /* @__PURE__ */ new Map();
 	writeChains = /* @__PURE__ */ new Map();
-	summaryIndex = null;
+	metadataStore;
+	summaryIndexStore;
 	constructor(journalDir) {
 		this.journalDir = journalDir;
+		this.metadataStore = new NcpAgentSessionMetadataStore(journalDir);
+		this.summaryIndexStore = new NcpAgentSessionSummaryIndexStore(journalDir, async (sessionId) => this.loadSession(sessionId));
 	}
 	appendSessionEvent = async (params) => {
 		const sessionId = normalizeNcpSessionId(params.session.sessionId);
@@ -4646,22 +4729,42 @@ var NcpAgentSessionJournalStore = class {
 		this.sessions.set(normalizedSessionId, loaded);
 		return structuredClone(loaded.record);
 	};
-	getSessionSummary = async (sessionId) => {
-		const normalizedSessionId = normalizeNcpSessionId(sessionId);
-		if (!normalizedSessionId) return null;
-		const indexed = (await this.loadSummaryIndex()).get(normalizedSessionId);
-		if (indexed) return structuredClone(indexed);
-		const record = await this.getSession(normalizedSessionId);
-		return record ? createNcpAgentSessionSummary(record) : null;
-	};
 	listSessionSummaries = async () => {
-		return [...(await this.loadSummaryIndex()).values()].map((summary) => structuredClone(summary)).sort((left, right) => readNcpSessionSummaryActivityAt(right).localeCompare(readNcpSessionSummaryActivityAt(left)));
+		return this.summaryIndexStore.list();
 	};
 	listSessionMessages = async (sessionId) => {
 		const session = await this.getSession(sessionId);
 		return session ? session.messages.map((message) => structuredClone(message)) : [];
 	};
-	replaceSession = async (record) => {
+	updateSessionMetadata = async (params) => {
+		const sessionId = normalizeNcpSessionId(params.sessionId);
+		if (!sessionId) return false;
+		const next = (this.writeChains.get(sessionId) ?? Promise.resolve()).then(() => this.updateSessionMetadataNow({
+			...params,
+			sessionId
+		}));
+		this.writeChains.set(sessionId, next.then(() => void 0, () => void 0));
+		return await next;
+	};
+	updateSessionMetadataNow = async (params) => {
+		const { metadata, sessionId, updatedAt } = params;
+		const loaded = this.sessions.get(sessionId) ?? await this.loadSession(sessionId);
+		if (!loaded) return false;
+		const nextRecord = {
+			...loaded.record,
+			metadata: structuredClone(metadata),
+			updatedAt
+		};
+		await this.metadataStore.write(nextRecord);
+		this.sessions.set(sessionId, {
+			record: nextRecord,
+			nextSeq: loaded.nextSeq
+		});
+		this.nextSeqBySession.set(sessionId, loaded.nextSeq);
+		await this.summaryIndexStore.upsert(createNcpAgentSessionSummary(nextRecord));
+		return true;
+	};
+	materializeSession = async (record) => {
 		const sessionId = normalizeNcpSessionId(record.sessionId);
 		if (!sessionId) return;
 		await this.ensureJournalDir();
@@ -4669,27 +4772,28 @@ var NcpAgentSessionJournalStore = class {
 			...record,
 			sessionId
 		});
-		const entries = [createNcpAgentSessionJournalMetadataEntry(nextRecord), ...nextRecord.messages.map((message, index) => ({
+		await this.metadataStore.write(nextRecord);
+		const entries = nextRecord.messages.map((message, index) => ({
 			_type: "event",
 			version: 1,
 			seq: index + 1,
 			timestamp: message.timestamp ?? nextRecord.updatedAt,
 			event: {
-				type: NcpEventType.MessageSent,
+				type: NCP_AGENT_SESSION_SNAPSHOT_MESSAGE_EVENT_TYPE,
 				payload: {
 					sessionId,
 					message: structuredClone(message)
 				}
 			}
-		}))];
-		await writeFile(this.sessionPath(sessionId), `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf-8");
+		}));
+		await writeFile(this.sessionPath(sessionId), entries.length > 0 ? `${entries.map(serializeJournalEntry).join("\n")}\n` : "", "utf-8");
 		const nextSeq = nextRecord.messages.length + 1;
 		this.sessions.set(sessionId, {
 			record: nextRecord,
 			nextSeq
 		});
 		this.nextSeqBySession.set(sessionId, nextSeq);
-		await this.upsertSummaryIndex(createNcpAgentSessionSummary(nextRecord));
+		await this.summaryIndexStore.upsert(createNcpAgentSessionSummary(nextRecord));
 	};
 	deleteSession = async (sessionId) => {
 		const normalizedSessionId = normalizeNcpSessionId(sessionId);
@@ -4700,23 +4804,31 @@ var NcpAgentSessionJournalStore = class {
 		try {
 			await unlink(this.sessionPath(normalizedSessionId));
 		} catch {}
-		await this.removeSummaryIndex(normalizedSessionId);
+		await this.metadataStore.delete(normalizedSessionId);
+		await this.summaryIndexStore.remove(normalizedSessionId);
 		return existing;
 	};
 	hasSession = async (sessionId) => {
 		const normalizedSessionId = normalizeNcpSessionId(sessionId);
 		if (!normalizedSessionId) return false;
-		return (await this.loadSummaryIndex()).has(normalizedSessionId);
+		return this.summaryIndexStore.has(normalizedSessionId);
 	};
 	appendSessionEventNow = async (params) => {
 		const { event, session, updatedAt } = params;
 		const { sessionId } = session;
 		await this.ensureJournalDir();
 		const existing = this.sessions.get(sessionId) ?? (this.nextSeqBySession.has(sessionId) ? null : await this.loadSession(sessionId));
-		const hasJournal = Boolean(existing) || this.nextSeqBySession.has(sessionId);
 		const nextSeq = this.nextSeqBySession.get(sessionId) ?? existing?.nextSeq ?? 1;
 		const path = this.sessionPath(sessionId);
-		if (!hasJournal) await appendFile(path, `${JSON.stringify(createNcpAgentSessionJournalMetadataEntry(session))}\n`, "utf-8");
+		await this.metadataStore.write({
+			...session,
+			...existing?.record.createdAt ? { createdAt: existing.record.createdAt } : {},
+			updatedAt,
+			metadata: {
+				...existing?.record.metadata ? structuredClone(existing.record.metadata) : {},
+				...session.metadata ? structuredClone(session.metadata) : {}
+			}
+		});
 		const entry = {
 			_type: "event",
 			version: 1,
@@ -4724,10 +4836,10 @@ var NcpAgentSessionJournalStore = class {
 			timestamp: updatedAt,
 			event: structuredClone(event)
 		};
-		await appendFile(path, `${JSON.stringify(entry)}\n`, "utf-8");
+		await this.appendJournalEntry(path, entry);
 		this.nextSeqBySession.set(sessionId, nextSeq + 1);
 		this.sessions.delete(sessionId);
-		await this.upsertSummaryIndexForEvent({
+		await this.summaryIndexStore.upsertForEvent({
 			session,
 			event,
 			updatedAt
@@ -4740,7 +4852,9 @@ var NcpAgentSessionJournalStore = class {
 		} catch {
 			return null;
 		}
-		const { agentId, createdAt, events, metadata, nextSeq, updatedAt } = this.parseSessionJournal(raw);
+		const parsedJournal = this.parseSessionJournal(raw);
+		const { agentId, createdAt, updatedAt, metadata } = await this.metadataStore.read(sessionId, parsedJournal);
+		const { events, nextSeq } = parsedJournal;
 		const messages = await replayNcpAgentSessionEvents(events);
 		const record = {
 			sessionId,
@@ -4763,9 +4877,15 @@ var NcpAgentSessionJournalStore = class {
 		let updatedAt = createdAt;
 		let nextSeq = 1;
 		const events = [];
-		for (const line of raw.split("\n")) {
+		for (const [index, line] of raw.split("\n").entries()) {
 			if (!line.trim()) continue;
-			const parsed = JSON.parse(line);
+			let parsed;
+			try {
+				parsed = JSON.parse(line);
+			} catch (error) {
+				console.warn(`[ncp-agent-session-journal] skipped corrupted journal line ${index + 1}: ${error instanceof Error ? error.message : String(error)}`);
+				continue;
+			}
 			if (!isRecord$1(parsed)) continue;
 			if (parsed._type === "metadata") {
 				metadata = isRecord$1(parsed.metadata) ? structuredClone(parsed.metadata) : {};
@@ -4790,72 +4910,125 @@ var NcpAgentSessionJournalStore = class {
 			events
 		};
 	};
-	loadSummaryIndex = async () => {
-		if (this.summaryIndex) return this.summaryIndex;
-		try {
-			const parsed = JSON.parse(await readFile(this.indexPath(), "utf-8"));
-			if (parsed.version === 1 && Array.isArray(parsed.records)) {
-				this.summaryIndex = new Map(parsed.records.map((record) => [record.sessionId, structuredClone(record)]));
-				return this.summaryIndex;
-			}
-		} catch {}
-		this.summaryIndex = await this.rebuildSummaryIndex();
-		await this.persistSummaryIndex();
-		return this.summaryIndex;
+	appendJournalEntry = async (path, entry) => {
+		await appendFile(path, `${serializeJournalEntry(entry)}\n`, "utf-8");
 	};
-	rebuildSummaryIndex = async () => {
-		const records = /* @__PURE__ */ new Map();
-		let entries = [];
-		try {
-			entries = await readdir(this.journalDir);
-		} catch {
-			return records;
-		}
-		for (const entry of entries) {
-			if (!entry.endsWith(".jsonl")) continue;
-			const sessionId = entry.replace(/\.jsonl$/, "").replace(/_/g, ":");
-			const loaded = await this.loadSession(sessionId);
-			if (!loaded) continue;
-			this.sessions.set(sessionId, loaded);
-			records.set(sessionId, createNcpAgentSessionSummary(loaded.record));
-		}
-		return records;
+	ensureJournalDir = async () => {
+		await mkdir(this.journalDir, { recursive: true });
 	};
-	upsertSummaryIndex = async (summary) => {
-		(await this.loadSummaryIndex()).set(summary.sessionId, structuredClone(summary));
-		await this.persistSummaryIndex();
+	sessionPath = (sessionId) => {
+		return join(this.journalDir, `${safeNcpSessionFilename(sessionId.replace(/:/g, "_"))}.jsonl`);
 	};
-	upsertSummaryIndexForEvent = async (params) => {
-		const { event, session, updatedAt } = params;
-		const index = await this.loadSummaryIndex();
-		const summary = upsertNcpAgentSessionSummaryEvent({
-			current: index.get(session.sessionId),
-			session,
-			event,
-			updatedAt
-		});
-		index.set(summary.sessionId, summary);
-		await this.persistSummaryIndex();
+};
+//#endregion
+//#region src/contributions/session-context-window/index.ts
+const STREAM_REFRESH_DELAY_MS = 1500;
+function formatBackgroundError$1(error) {
+	if (error instanceof Error) return error.stack ?? error.message;
+	return String(error);
+}
+function readEventSessionId(event) {
+	const payload = "payload" in event ? event.payload : null;
+	if (!payload || typeof payload !== "object") return null;
+	return "sessionId" in payload && typeof payload.sessionId === "string" ? payload.sessionId.trim() || null : null;
+}
+function isContextWindow(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function createSignature(value) {
+	return JSON.stringify(value);
+}
+function shouldRefreshDuringStream(event) {
+	switch (event.type) {
+		case NcpEventType.MessageTextDelta:
+		case NcpEventType.MessageReasoningDelta:
+		case NcpEventType.MessageToolCallArgsDelta:
+		case NcpEventType.MessageToolCallResult: return true;
+		default: return false;
+	}
+}
+function shouldRefreshImmediately(event) {
+	switch (event.type) {
+		case NcpEventType.MessageCompleted:
+		case NcpEventType.MessageFailed:
+		case NcpEventType.MessageAbort:
+		case NcpEventType.RunFinished:
+		case NcpEventType.RunError: return true;
+		default: return false;
+	}
+}
+var SessionContextWindowContribution = class {
+	unsubscribeNcpEvent = null;
+	stopped = true;
+	pendingTimers = /* @__PURE__ */ new Map();
+	lastPublishedSignatureBySession = /* @__PURE__ */ new Map();
+	constructor(kernel) {
+		this.kernel = kernel;
+	}
+	start = () => {
+		if (this.unsubscribeNcpEvent) return;
+		this.stopped = false;
+		this.unsubscribeNcpEvent = this.kernel.eventBus.on(eventKeys.ncpEvent, this.handleNcpEvent);
 	};
-	removeSummaryIndex = async (sessionId) => {
-		(await this.loadSummaryIndex()).delete(sessionId);
-		await this.persistSummaryIndex();
+	dispose = () => {
+		this.unsubscribeNcpEvent?.();
+		this.unsubscribeNcpEvent = null;
+		this.stopped = true;
+		for (const timer of this.pendingTimers.values()) clearTimeout(timer);
+		this.pendingTimers.clear();
+		this.lastPublishedSignatureBySession.clear();
 	};
-	persistSummaryIndex = async () => {
-		const records = [...this.summaryIndex?.values() ?? []].map((summary) => structuredClone(summary)).sort((left, right) => readNcpSessionSummaryActivityAt(right).localeCompare(readNcpSessionSummaryActivityAt(left)));
-		await this.ensureJournalDir();
-		await writeFile(this.indexPath(), `${JSON.stringify({
-			version: 1,
-			records
-		})}\n`, "utf-8");
+	handleNcpEvent = (event) => {
+		const sessionId = readEventSessionId(event);
+		if (!sessionId) return;
+		if (event.type === NcpEventType.ContextWindowUpdated) {
+			this.rememberPublishedContextWindow(sessionId, event.payload.contextWindow);
+			return;
+		}
+		if (shouldRefreshImmediately(event)) {
+			this.refreshNow(sessionId);
+			return;
+		}
+		if (shouldRefreshDuringStream(event)) this.refreshSoon(sessionId);
+	};
+	refreshSoon = (sessionId) => {
+		if (this.pendingTimers.has(sessionId)) return;
+		const timer = setTimeout(() => {
+			this.pendingTimers.delete(sessionId);
+			this.refreshNow(sessionId);
+		}, STREAM_REFRESH_DELAY_MS);
+		this.pendingTimers.set(sessionId, timer);
+	};
+	refreshNow = (sessionId) => {
+		const timer = this.pendingTimers.get(sessionId);
+		if (timer) {
+			clearTimeout(timer);
+			this.pendingTimers.delete(sessionId);
+		}
+		this.publishContextWindow(sessionId).catch((error) => {
+			console.error(`[session-context-window] failed to refresh ${sessionId}: ${formatBackgroundError$1(error)}`);
+		});
 	};
-	ensureJournalDir = async () => {
-		await mkdir(this.journalDir, { recursive: true });
+	publishContextWindow = async (sessionId) => {
+		if (this.stopped) return;
+		const contextWindow = (await this.kernel.ncpSessionApi.getSession(sessionId))?.contextWindow;
+		if (!isContextWindow(contextWindow) || this.stopped) return;
+		const endpoint = this.kernel.agentRuntimeManager.currentHandle?.agentClientEndpoint;
+		if (!endpoint) return;
+		const signature = createSignature(contextWindow);
+		if (this.lastPublishedSignatureBySession.get(sessionId) === signature) return;
+		this.lastPublishedSignatureBySession.set(sessionId, signature);
+		await endpoint.emit({
+			type: NcpEventType.ContextWindowUpdated,
+			payload: {
+				sessionId,
+				contextWindow
+			}
+		});
 	};
-	sessionPath = (sessionId) => {
-		return join(this.journalDir, `${safeNcpSessionFilename(sessionId.replace(/:/g, "_"))}.jsonl`);
+	rememberPublishedContextWindow = (sessionId, contextWindow) => {
+		this.lastPublishedSignatureBySession.set(sessionId, createSignature(contextWindow));
 	};
-	indexPath = () => resolve(this.journalDir, NCP_AGENT_SESSION_JOURNAL_INDEX_FILE);
 };
 //#endregion
 //#region src/contributions/session-activity-preview/utils/session-activity-preview-ncp-event.utils.ts
@@ -5159,7 +5332,7 @@ var NextclawKernel = class {
 			sessionRequester: this.sessionRequests,
 			resolveLearningLoopConfig: () => readLearningLoopRuntimeConfig(this.configManager.loadConfig())
 		});
-		this.contributions = [new SessionActivityPreviewContribution(this)];
+		this.contributions = [new SessionActivityPreviewContribution(this), new SessionContextWindowContribution(this)];
 	}
 	start = async () => {
 		this.ncpSessionApi.start();
@@ -5187,4 +5360,4 @@ var NextclawKernel = class {
 	};
 };
 //#endregion
-export { AGENT_RUNTIME_SESSION_MESSAGE_INGRESS_TYPE, AgentManager, AgentRuntimeManager, AgentRuntimeRegistry, AutomationManager, BuiltinNarpRuntimeRegistrationService, ChannelManager, ConfigManager, ContextCompactionPreflightService, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DEFAULT_LEARNING_LOOP_TOOL_CALL_THRESHOLD, ExtensionManager, 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, LlmProviderManager, LlmUsageManager, LlmUsageStore, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NativeAgentRuntimeFactory, NcpSessionApiService, NextclawKernel, NextclawNcpContextBuilder, NextclawNcpToolRegistry, PluginRuntimeRegistrationController, ProviderManagerNcpLLMApi, SkillManager, ToolManager, UpdateManifestReader, 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 };
+export { AGENT_RUNTIME_SESSION_MESSAGE_INGRESS_TYPE, AgentManager, AgentRuntimeManager, AgentRuntimeRegistry, AutomationManager, BuiltinNarpRuntimeRegistrationService, ChannelManager, ConfigManager, ContextCompactionPreflightService, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DEFAULT_LEARNING_LOOP_TOOL_CALL_THRESHOLD, ExtensionManager, 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, LlmProviderManager, LlmUsageManager, LlmUsageStore, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NativeAgentRuntimeFactory, NcpSessionApiService, NextclawKernel, NextclawNcpContextBuilder, NextclawNcpToolRegistry, PluginRuntimeRegistrationController, ProviderManagerNcpLLMApi, SkillManager, ToolManager, UpdateManifestReader, buildLearningLoopTask, buildLlmUsageSummary, buildNcpUserMessage, buildUserMessageParts, createAgentRuntimeHandle, createAgentRuntimeSessionRequestDispatcher, createAssetTools, createLlmUsageRecord, createNcpSessionSummary, dispatchAgentRuntimeSessionRequest, dispatchChannelReplyRoute, dispatchPromptOverNcp, getUnsignedUpdateManifest, hasLlmUsageTelemetry, isReplyCapableChannel, normalizeAgentRuntimeSessionTypeIcon, normalizeLlmUsageModel, readLearningLoopRuntimeConfig, resolveAgentHandoffDepth, resolveAgentRuntimeEntries, resolveChannelReplyRoute, resolveLegacyEventType, runGatewayInboundLoop, runPromptOverNcp, sanitizeLlmUsage, serializeUnsignedUpdateManifest, streamPromptOverNcp, toNcpMessages, waitForAgentRuntimeSessionReply };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/kernel",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "private": false,
   "description": "NextClaw product kernel skeleton for agents, tasks, sessions, context, tools, skills, providers, automation, and channels.",
   "type": "module",
@@ -20,19 +20,19 @@
     "dist"
   ],
   "dependencies": {
-    "@nextclaw/core": "0.12.17",
-    "@nextclaw/mcp": "0.1.82",
-    "@nextclaw/ncp-agent-runtime": "0.3.20",
-    "@nextclaw/ncp-http-agent-server": "0.3.22",
-    "@nextclaw/nextclaw-hermes-acp-bridge": "0.1.9",
-    "@nextclaw/ncp-toolkit": "0.5.15",
-    "@nextclaw/nextclaw-ncp-runtime-http-client": "0.1.9",
-    "@nextclaw/openclaw-compat": "1.0.17",
-    "@nextclaw/runtime": "0.2.49",
-    "@nextclaw/nextclaw-ncp-runtime-stdio-client": "0.1.10",
-    "@nextclaw/shared": "0.1.4",
-    "@nextclaw/ncp": "0.5.10",
-    "@nextclaw/ncp-mcp": "0.1.84"
+    "@nextclaw/core": "0.12.19",
+    "@nextclaw/mcp": "0.1.84",
+    "@nextclaw/ncp-agent-runtime": "0.3.22",
+    "@nextclaw/ncp-mcp": "0.1.86",
+    "@nextclaw/ncp-http-agent-server": "0.3.24",
+    "@nextclaw/ncp-toolkit": "0.5.17",
+    "@nextclaw/nextclaw-ncp-runtime-http-client": "0.1.11",
+    "@nextclaw/nextclaw-hermes-acp-bridge": "0.1.11",
+    "@nextclaw/shared": "0.1.6",
+    "@nextclaw/runtime": "0.2.51",
+    "@nextclaw/openclaw-compat": "1.0.19",
+    "@nextclaw/nextclaw-ncp-runtime-stdio-client": "0.1.12",
+    "@nextclaw/ncp": "0.5.12"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",