@nextclaw/kernel 0.1.4 → 0.1.6

package/dist/index.js

@@ -3,9 +3,9 @@ import { AgentRouteResolver, CONTEXT_COMPACTION_METADATA_KEY, ChannelManager, Ch
 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 { DefaultNcpAgentBackend, createAgentClientFromServer } from "@nextclaw/ncp-toolkit";
+import { DefaultNcpAgentBackend, DefaultNcpAgentConversationStateManager, createAgentClientFromServer } from "@nextclaw/ncp-toolkit";
 import { basename, delimiter, dirname, join, resolve } from "node:path";
-import { access, readFile } from "node:fs/promises";
+import { access, appendFile, mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
 import { appendFileSync, constants, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { BUILTIN_PROVIDER_PLUGINS } from "@nextclaw/runtime";
 import { HttpRuntimeConfigResolver, HttpRuntimeNcpAgentRuntime } from "@nextclaw/nextclaw-ncp-runtime-http-client";
@@ -592,10 +592,10 @@ var AgentRuntimeRegistry = class {
 //#endregion
 //#region src/features/ncp-dispatch/utils/agent-runtime-handle.utils.ts
 function createAgentRuntimeHandle(params) {
-	const { backend, runtimeRegistry, refreshPluginRuntimeRegistrations, refreshConfiguredRuntimeEntries, applyMcpConfig, dispose, assetStore } = params;
+	const { agentClientEndpoint, backend, runtimeRegistry, refreshPluginRuntimeRegistrations, refreshConfiguredRuntimeEntries, applyMcpConfig, dispose, assetStore } = params;
 	return {
 		basePath: "/api/ncp/agent",
-		agentClientEndpoint: createAgentClientFromServer(backend),
+		agentClientEndpoint: agentClientEndpoint ?? createAgentClientFromServer(backend),
 		streamProvider: backend,
 		runApi: backend,
 		sessionApi: backend,
@@ -625,11 +625,11 @@ function normalizeString(value) {
 	const trimmed = value.trim();
 	return trimmed.length > 0 ? trimmed : null;
 }
-function isRecord$3(value) {
+function isRecord$5(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function cloneMetadata(value) {
-	return isRecord$3(value) ? structuredClone(value) : void 0;
+	return isRecord$5(value) ? structuredClone(value) : void 0;
 }
 function readStringArray(value) {
 	if (!Array.isArray(value)) return null;
@@ -1876,7 +1876,7 @@ var LlmUsageManager = class {
 };
 //#endregion
 //#region src/tools/session-search.tools.ts
-function isRecord$2(value) {
+function isRecord$4(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function readOptionalInteger(value) {
@@ -1926,7 +1926,7 @@ var SessionSearchTool = class {
 		return issues;
 	};
 	execute = async (args) => {
-		if (!isRecord$2(args)) throw new Error("session_search requires an object argument.");
+		if (!isRecord$4(args)) throw new Error("session_search requires an object argument.");
 		const issues = this.validateArgs(args);
 		if (issues.length > 0) throw new Error(issues.join(" "));
 		return this.queryService.search({
@@ -1939,13 +1939,13 @@ var SessionSearchTool = class {
 };
 //#endregion
 //#region src/features/native-runtime/tools/ncp-asset.tools.ts
-function readOptionalString$2(value) {
+function readOptionalString$4(value) {
 	if (typeof value !== "string") return null;
 	const trimmed = value.trim();
 	return trimmed.length > 0 ? trimmed : null;
 }
 function readOptionalBase64Bytes(value) {
-	const base64 = readOptionalString$2(value);
+	const base64 = readOptionalString$4(value);
 	if (!base64) return null;
 	try {
 		return Buffer.from(base64, "base64");
@@ -1996,18 +1996,18 @@ var AssetPutTool = class {
 		this.contentBasePath = contentBasePath;
 	}
 	validateArgs = (args) => {
-		const path = readOptionalString$2(args.path);
-		const bytesBase64 = readOptionalString$2(args.bytesBase64);
-		const fileName = readOptionalString$2(args.fileName);
+		const path = readOptionalString$4(args.path);
+		const bytesBase64 = readOptionalString$4(args.bytesBase64);
+		const fileName = readOptionalString$4(args.fileName);
 		if (path && bytesBase64) return ["Provide either path, or bytesBase64 + fileName, not both."];
 		if (path) return [];
 		if (bytesBase64) return fileName ? [] : ["fileName is required when using bytesBase64."];
 		return ["Provide either path, or bytesBase64 + fileName."];
 	};
 	execute = async (args) => {
-		const path = readOptionalString$2(args?.path);
-		const fileName = readOptionalString$2(args?.fileName);
-		const mimeType = readOptionalString$2(args?.mimeType);
+		const path = readOptionalString$4(args?.path);
+		const fileName = readOptionalString$4(args?.fileName);
+		const mimeType = readOptionalString$4(args?.mimeType);
 		const bytes = readOptionalBase64Bytes(args?.bytesBase64);
 		if (path) return {
 			ok: true,
@@ -2050,8 +2050,8 @@ var AssetExportTool = class {
 		this.assetStore = assetStore;
 	}
 	execute = async (args) => {
-		const assetUri = readOptionalString$2(args?.assetUri);
-		const targetPath = readOptionalString$2(args?.targetPath);
+		const assetUri = readOptionalString$4(args?.assetUri);
+		const targetPath = readOptionalString$4(args?.targetPath);
 		if (!assetUri || !targetPath) throw new Error("asset_export requires assetUri and targetPath.");
 		return {
 			ok: true,
@@ -2077,7 +2077,7 @@ var AssetStatTool = class {
 		this.contentBasePath = contentBasePath;
 	}
 	execute = async (args) => {
-		const assetUri = readOptionalString$2(args?.assetUri);
+		const assetUri = readOptionalString$4(args?.assetUri);
 		if (!assetUri) throw new Error("asset_stat requires assetUri.");
 		const record = await this.assetStore.statRecord(assetUri);
 		if (!record) return {
@@ -2252,7 +2252,7 @@ function readRequiredString$1(params, key) {
 	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${key} must be a non-empty string.`);
 	return value.trim();
 }
-function readOptionalString$1(params, key) {
+function readOptionalString$3(params, key) {
 	const value = params[key];
 	if (typeof value !== "string") return;
 	const trimmed = value.trim();
@@ -2313,7 +2313,7 @@ var SessionRequestTool = class extends Tool {
 		const target = params.target;
 		if (!target || typeof target !== "object" || Array.isArray(target)) throw new Error("target must be an object.");
 		const task = readRequiredString$1(params, "task");
-		const notifyMode = readOptionalString$1(params, "notify")?.toLowerCase();
+		const notifyMode = readOptionalString$3(params, "notify")?.toLowerCase();
 		if (notifyMode !== "none" && notifyMode !== "final_reply") throw new Error("notify must be \"none\" or \"final_reply\".");
 		const { toolCallId, updateToolCallResult } = context;
 		return this.manager.requestSession({
@@ -2322,7 +2322,7 @@ var SessionRequestTool = class extends Tool {
 			updateToolCallResult,
 			targetSessionId: readRequiredString$1(target, "session_id"),
 			task,
-			title: readOptionalString$1(params, "title"),
+			title: readOptionalString$3(params, "title"),
 			notify: notifyMode,
 			handoffDepth: this.handoffDepth
 		});
@@ -2334,13 +2334,13 @@ function readRequiredString(value, key) {
 	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${key} must be a non-empty string.`);
 	return value.trim();
 }
-function readOptionalString(value) {
+function readOptionalString$2(value) {
 	if (typeof value !== "string") return;
 	const trimmed = value.trim();
 	return trimmed.length > 0 ? trimmed : void 0;
 }
 function readSpawnScope(value) {
-	const normalized = readOptionalString(value)?.toLowerCase();
+	const normalized = readOptionalString$2(value)?.toLowerCase();
 	if (!normalized || normalized === "standalone") return "standalone";
 	if (normalized === "child") return "child";
 	throw new Error("scope must be \"standalone\" or \"child\".");
@@ -2348,7 +2348,7 @@ function readSpawnScope(value) {
 function readSpawnRequestOptions(value) {
 	if (typeof value === "undefined") return;
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("request must be an object.");
-	const notifyMode = readOptionalString(value.notify)?.toLowerCase();
+	const notifyMode = readOptionalString$2(value.notify)?.toLowerCase();
 	if (notifyMode === "none" || notifyMode === "final_reply") return { notify: notifyMode };
 	throw new Error("request.notify must be \"none\" or \"final_reply\".");
 }
@@ -2429,10 +2429,10 @@ var SessionSpawnTool = class extends Tool {
 			updateToolCallResult,
 			sourceSessionMetadata: this.sourceSessionMetadata,
 			task,
-			title: readOptionalString(rawTitle),
-			agentId: readOptionalString(rawAgentId),
-			model: readOptionalString(rawModel),
-			runtime: readOptionalString(rawRuntime),
+			title: readOptionalString$2(rawTitle),
+			agentId: readOptionalString$2(rawAgentId),
+			model: readOptionalString$2(rawModel),
+			runtime: readOptionalString$2(rawRuntime),
 			handoffDepth: this.handoffDepth,
 			...parentSessionId ? { parentSessionId } : {},
 			notify: request.notify
@@ -2440,11 +2440,11 @@ var SessionSpawnTool = class extends Tool {
 		const session = this.sessionManager.createSession({
 			sourceSessionId: this.sourceSessionId,
 			task,
-			title: readOptionalString(rawTitle),
+			title: readOptionalString$2(rawTitle),
 			sourceSessionMetadata: this.sourceSessionMetadata,
-			agentId: readOptionalString(rawAgentId),
-			model: readOptionalString(rawModel),
-			runtime: readOptionalString(rawRuntime),
+			agentId: readOptionalString$2(rawAgentId),
+			model: readOptionalString$2(rawModel),
+			runtime: readOptionalString$2(rawRuntime),
 			...parentSessionId ? { parentSessionId } : {}
 		});
 		this.onSessionUpdated?.(session.sessionId);
@@ -2469,10 +2469,10 @@ var SessionSpawnTool = class extends Tool {
 //#endregion
 //#region src/features/native-runtime/services/nextclaw-ncp-tool-registry.service.ts
 function toToolParams(args) {
-	if (isRecord$3(args)) return args;
+	if (isRecord$5(args)) return args;
 	if (typeof args === "string") try {
 		const parsed = JSON.parse(args);
-		return isRecord$3(parsed) ? parsed : {};
+		return isRecord$5(parsed) ? parsed : {};
 	} catch {
 		return {};
 	}
@@ -2664,14 +2664,14 @@ function readAccountIdForHints(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, /(现在|此刻|当前时间|现在几点|几点了|今天|今晚|今早|今晨|明天|昨天|日期)/];
-function isRecord$1(value) {
+function isRecord$3(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function mergeInputMetadata(input) {
-	const messageMetadata = input.messages.slice().reverse().find((message) => isRecord$1(message.metadata))?.metadata;
+	const messageMetadata = input.messages.slice().reverse().find((message) => isRecord$3(message.metadata))?.metadata;
 	return {
-		...isRecord$1(messageMetadata) ? structuredClone(messageMetadata) : {},
-		...isRecord$1(input.metadata) ? structuredClone(input.metadata) : {}
+		...isRecord$3(messageMetadata) ? structuredClone(messageMetadata) : {},
+		...isRecord$3(input.metadata) ? structuredClone(input.metadata) : {}
 	};
 }
 const REQUESTED_SKILLS_METADATA_READER = new RequestedSkillsMetadataReader();
@@ -2978,12 +2978,12 @@ function createContextWindowUpdatedEvent(params) {
 		}
 	};
 }
-function isRecord(value) {
+function isRecord$2(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function resolveNativeReasoningNormalizationMode(params) {
 	const runtimeEntry = params.config.agents.runtimes.entries.native?.config ?? params.config.ui.ncp.runtimes.native;
-	const runtimeMetadata = isRecord(runtimeEntry) ? runtimeEntry : {};
+	const runtimeMetadata = isRecord$2(runtimeEntry) ? runtimeEntry : {};
 	return readAssistantReasoningNormalizationModeFromMetadata(params.sessionMetadata) ?? readAssistantReasoningNormalizationMode(runtimeMetadata.reasoningNormalization) ?? readAssistantReasoningNormalizationMode(runtimeMetadata.reasoning_normalization) ?? readAssistantReasoningNormalizationMode(runtimeMetadata.reasoningNormalizationMode) ?? readAssistantReasoningNormalizationMode(runtimeMetadata.reasoning_normalization_mode) ?? "think-tags";
 }
 function createSessionSearchTools(params) {
@@ -3240,6 +3240,24 @@ function createAgentRuntimeSessionRequestDispatcher(options) {
 }
 //#endregion
 //#region src/managers/agent-runtime.manager.ts
+function readOptionalString$1(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function readMessageTask(message) {
+	for (const part of message.parts) if ((part.type === "text" || part.type === "rich-text" || part.type === "reasoning") && part.text.trim()) return part.text.trim();
+	return "Session";
+}
+function readSessionMetadataString(metadata, ...keys) {
+	for (const key of keys) {
+		const value = readOptionalString$1(metadata?.[key]);
+		if (value) return value;
+	}
+}
+async function consumeAgentEvents(events) {
+	for await (const event of events);
+}
 var AgentRuntimeManager = class {
 	runtimeRegistry = new AgentRuntimeRegistry();
 	mcpRuntimeSupport;
@@ -3268,6 +3286,7 @@ var AgentRuntimeManager = class {
 	get currentHandle() {
 		return this.handle;
 	}
+	isLiveSessionRunning = (sessionId) => this.backend?.isLiveSessionRunning(sessionId) ?? false;
 	connectGatewayController = (gatewayController) => {
 		this.assertNotDisposed();
 		this.gatewayController = gatewayController;
@@ -3321,6 +3340,7 @@ var AgentRuntimeManager = class {
 		await this.backend.start();
 		this.handle = createAgentRuntimeHandle({
 			backend: this.backend,
+			agentClientEndpoint: this.createMaterializingAgentClientEndpoint(this.backend),
 			runtimeRegistry: this.runtimeRegistry,
 			refreshPluginRuntimeRegistrations: this.pluginRuntimeRegistrationController.refreshPluginRuntimeRegistrations,
 			refreshConfiguredRuntimeEntries: this.refreshConfiguredRuntimeEntries,
@@ -3330,6 +3350,68 @@ var AgentRuntimeManager = class {
 		});
 		return this.handle;
 	};
+	materializeAgentSendEnvelope = (envelope) => {
+		const existingSessionId = readOptionalString$1(envelope.sessionId) ?? readOptionalString$1(envelope.message.sessionId);
+		if (existingSessionId) return {
+			...envelope,
+			sessionId: existingSessionId,
+			message: {
+				...envelope.message,
+				sessionId: existingSessionId
+			}
+		};
+		const metadata = envelope.metadata ?? {};
+		const createdSession = this.params.sessions.createSession({
+			task: readMessageTask(envelope.message),
+			title: readSessionMetadataString(metadata, "label", "title"),
+			sourceSessionMetadata: {},
+			metadataOverrides: metadata,
+			agentId: readSessionMetadataString(metadata, "agent_id", "agentId"),
+			model: readSessionMetadataString(metadata, "preferred_model", "model"),
+			runtime: readSessionMetadataString(metadata, "runtime", "session_type"),
+			sessionType: readSessionMetadataString(metadata, "session_type", "runtime"),
+			thinkingLevel: readSessionMetadataString(metadata, "preferred_thinking", "thinking"),
+			projectRoot: readSessionMetadataString(metadata, "project_root")
+		});
+		this.params.onSessionUpdated(createdSession.sessionId);
+		return {
+			...envelope,
+			sessionId: createdSession.sessionId,
+			message: {
+				...envelope.message,
+				sessionId: createdSession.sessionId
+			}
+		};
+	};
+	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);
+			}
+		}
+	});
 	warmDerivedCapabilities = async () => {
 		this.assertNotDisposed();
 		this.warmupPromise ??= this.runDerivedCapabilityWarmup();
@@ -4069,11 +4151,12 @@ var NcpLifecycleEventBridge = class {
 //#endregion
 //#region src/utils/ncp-session-summary.utils.ts
 function createNcpSessionSummary(params) {
-	const { sessionId, agentId, messages, updatedAt, status, metadata, contextWindow } = params;
+	const { sessionId, agentId, messages, createdAt, updatedAt, status, metadata, contextWindow } = params;
 	return {
 		sessionId,
 		...agentId ? { agentId } : {},
 		messageCount: messages.length,
+		createdAt,
 		updatedAt,
 		...messages.length > 0 ? { lastMessageAt: messages[messages.length - 1]?.timestamp ?? updatedAt } : {},
 		status,
@@ -4100,6 +4183,18 @@ function buildUpdatedMetadata(params) {
 function normalizeSessionId(sessionId) {
 	return sessionId.trim();
 }
+function createSessionListSummary(record) {
+	return {
+		sessionId: record.sessionId,
+		...record.agentId ? { agentId: record.agentId } : {},
+		messageCount: record.messageCount ?? 0,
+		createdAt: record.created_at,
+		updatedAt: record.updated_at,
+		...record.lastMessageAt ? { lastMessageAt: record.lastMessageAt } : {},
+		status: "idle",
+		metadata: structuredClone(record.metadata)
+	};
+}
 var NcpSessionApiService = class {
 	unsubscribeSessionUpdated = null;
 	contextWindowPreview;
@@ -4133,39 +4228,47 @@ var NcpSessionApiService = class {
 		this.options.eventBus.emit(eventKeys.sessionSummaryDelete, { sessionKey: normalizedSessionKey });
 	};
 	listSessions = async (options) => {
-		const summaries = [];
-		for (const record of this.options.sessionManager.listSessions()) {
-			const sessionId = normalizeSessionId(record.key);
-			if (!sessionId) continue;
-			const session = this.options.sessionManager.getIfExists(sessionId);
-			if (!session) continue;
-			summaries.push(createNcpSessionSummary({
-				sessionId,
-				agentId: session.agentId,
-				messages: toNcpMessages(sessionId, session.messages),
-				updatedAt: session.updatedAt.toISOString(),
-				status: "idle",
-				metadata: session.metadata
-			}));
-		}
-		summaries.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-		return applyLimit(summaries, options?.limit);
+		if (this.options.ncpAgentSessionStore?.listSessionSummaries) return applyLimit(await this.options.ncpAgentSessionStore.listSessionSummaries(), options?.limit).map(this.withLiveSessionStatus);
+		return applyLimit(this.options.sessionManager.listSessions().map((record) => ({
+			...record,
+			sessionId: normalizeSessionId(record.key)
+		})).filter((record) => Boolean(record)).sort((left, right) => (right.lastMessageAt ?? right.created_at).localeCompare(left.lastMessageAt ?? left.created_at)), options?.limit).map(createSessionListSummary).map(this.withLiveSessionStatus);
 	};
 	listSessionMessages = async (sessionId, options) => {
 		const normalizedSessionId = normalizeSessionId(sessionId);
+		if (normalizedSessionId && this.options.ncpAgentSessionStore?.listSessionMessages) return applyLimit(await this.options.ncpAgentSessionStore.listSessionMessages(normalizedSessionId), options?.limit);
 		const session = normalizedSessionId ? this.options.sessionManager.getIfExists(normalizedSessionId) : null;
 		if (!session) return [];
 		return applyLimit(toNcpMessages(normalizedSessionId, session.messages).map((message) => structuredClone(message)), options?.limit);
 	};
 	getSession = async (sessionId) => {
 		const normalizedSessionId = normalizeSessionId(sessionId);
+		if (normalizedSessionId && this.options.ncpAgentSessionStore?.getSession) {
+			const record = await this.options.ncpAgentSessionStore.getSession(normalizedSessionId);
+			if (record) return this.withLiveSessionStatus(createNcpSessionSummary({
+				sessionId: normalizedSessionId,
+				agentId: record.agentId,
+				messages: record.messages,
+				createdAt: record.createdAt ?? record.updatedAt,
+				updatedAt: record.updatedAt,
+				status: "idle",
+				metadata: record.metadata,
+				contextWindow: this.contextWindowPreview.preview({
+					contextWindowOwner: "nextclaw",
+					requestMetadata: record.metadata ?? {},
+					sessionId: normalizedSessionId,
+					sessionMessages: record.messages
+				})
+			}));
+		}
 		const session = normalizedSessionId ? this.options.sessionManager.getIfExists(normalizedSessionId) : null;
 		if (!session) return null;
 		const messages = toNcpMessages(normalizedSessionId, session.messages);
-		return createNcpSessionSummary({
+		return this.withLiveSessionStatus(createNcpSessionSummary({
 			sessionId: normalizedSessionId,
 			agentId: session.agentId,
 			messages,
+			createdAt: session.createdAt.toISOString(),
 			updatedAt: session.updatedAt.toISOString(),
 			status: "idle",
 			metadata: session.metadata,
@@ -4175,10 +4278,25 @@ var NcpSessionApiService = class {
 				sessionId: normalizedSessionId,
 				sessionMessages: messages
 			})
-		});
+		}));
 	};
 	updateSession = async (sessionId, patch) => {
 		const normalizedSessionId = normalizeSessionId(sessionId);
+		if (normalizedSessionId && this.options.ncpAgentSessionStore) {
+			const existing = await this.options.ncpAgentSessionStore.getSession(normalizedSessionId);
+			if (existing) {
+				await this.options.ncpAgentSessionStore.replaceSession({
+					...existing,
+					metadata: buildUpdatedMetadata({
+						existingMetadata: existing.metadata,
+						patch
+					}),
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				});
+				await this.publishSessionChange(normalizedSessionId);
+				return await this.getSession(normalizedSessionId);
+			}
+		}
 		const session = normalizedSessionId ? this.options.sessionManager.getIfExists(normalizedSessionId) : null;
 		if (!session) return null;
 		session.metadata = buildUpdatedMetadata({
@@ -4193,9 +4311,14 @@ var NcpSessionApiService = class {
 	deleteSession = async (sessionId) => {
 		const normalizedSessionId = normalizeSessionId(sessionId);
 		if (!normalizedSessionId) return;
+		if (this.options.ncpAgentSessionStore) await this.options.ncpAgentSessionStore.deleteSession(normalizedSessionId);
 		this.options.sessionManager.delete(normalizedSessionId);
 		await this.publishSessionChange(normalizedSessionId);
 	};
+	withLiveSessionStatus = (summary) => this.options.isLiveSessionRunning?.(summary.sessionId) ? {
+		...summary,
+		status: "running"
+	} : summary;
 };
 //#endregion
 //#region src/utils/ncp-session-metadata.utils.ts
@@ -4205,58 +4328,72 @@ function resolvePersistedSessionMetadata(params) {
 	return mergeSessionMetadata(preserveExistingMetadata ? mergeSessionMetadata(currentMetadata, messageMetadata) : mergeSessionMetadata({}, messageMetadata), cloneMetadata(sessionRecord.metadata));
 }
 //#endregion
-//#region src/services/ncp-agent-session-store-adapter.service.ts
-function readAgentIdFromMetadata(metadata) {
-	return normalizeString(metadata?.agent_id)?.toLowerCase() ?? normalizeString(metadata?.agentId)?.toLowerCase() ?? void 0;
-}
+//#region src/stores/ncp-agent-legacy-session.store.ts
 function resolveSessionRecordAgentId(record) {
-	return normalizeString(record.agentId)?.toLowerCase() ?? readAgentIdFromMetadata(record.metadata);
+	return normalizeString(record.agentId)?.toLowerCase() ?? normalizeString(record.metadata?.agent_id)?.toLowerCase() ?? normalizeString(record.metadata?.agentId)?.toLowerCase();
 }
-var NcpAgentSessionStoreAdapter = class {
+var NcpAgentLegacySessionStore = class {
 	constructor(sessionManager, options = {}) {
 		this.sessionManager = sessionManager;
 		this.options = options;
 	}
-	getSession = async (sessionId) => {
+	getSession = (sessionId) => {
 		const session = this.sessionManager.getIfExists(sessionId);
 		if (!session) return null;
 		return {
 			sessionId,
 			...session.agentId ? { agentId: session.agentId } : {},
 			messages: toNcpMessages(sessionId, session.messages),
+			createdAt: session.createdAt.toISOString(),
 			updatedAt: session.updatedAt.toISOString(),
 			metadata: structuredClone(session.metadata)
 		};
 	};
-	listSessions = async () => {
-		const records = this.sessionManager.listSessions();
-		const sessions = [];
-		for (const record of records) {
-			const sessionId = normalizeString(record.key);
-			if (!sessionId) continue;
-			const session = this.sessionManager.getIfExists(sessionId);
-			if (!session) continue;
-			sessions.push({
-				sessionId,
-				...session.agentId ? { agentId: session.agentId } : {},
-				messages: toNcpMessages(sessionId, session.messages),
-				updatedAt: session.updatedAt.toISOString(),
-				metadata: structuredClone(session.metadata)
-			});
-		}
-		sessions.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-		return sessions;
+	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
+		};
 	};
-	persistSession = async (sessionRecord, options) => {
-		if (this.options.writeMode === "runtime-owned") return;
+	listSessionMessages = (sessionId) => this.getSession(sessionId)?.messages ?? [];
+	listSessionSummaries = () => this.sessionManager.listSessions().map((record) => ({
+		sessionId: record.key,
+		...record.agentId ? { agentId: record.agentId } : {},
+		messageCount: record.messageCount ?? 0,
+		createdAt: record.created_at,
+		updatedAt: record.updated_at,
+		...record.lastMessageAt ? { lastMessageAt: record.lastMessageAt } : {},
+		status: "idle",
+		metadata: structuredClone(record.metadata)
+	}));
+	saveSession = (sessionRecord) => this.persistSession(sessionRecord, true);
+	replaceSession = (sessionRecord) => this.persistSession(sessionRecord, false);
+	deleteSession = (sessionId) => {
+		const existing = this.getSession(sessionId);
+		if (!existing) return null;
+		this.sessionManager.delete(sessionId);
+		this.options.onSessionUpdated?.(sessionId);
+		return existing;
+	};
+	persistSession = async (sessionRecord, preserveExistingMetadata) => {
 		const session = this.sessionManager.getIfExists(sessionRecord.sessionId) ?? this.sessionManager.getOrCreate(sessionRecord.sessionId);
 		const legacyMessages = toLegacyMessages(sessionRecord.messages);
 		const nextAgentId = resolveSessionRecordAgentId(sessionRecord);
 		if (nextAgentId) session.agentId = nextAgentId;
+		if (sessionRecord.createdAt) session.createdAt = new Date(ensureIsoTimestamp(sessionRecord.createdAt, session.createdAt.toISOString()));
 		session.metadata = resolvePersistedSessionMetadata({
 			currentMetadata: session.metadata,
 			sessionRecord,
-			preserveExistingMetadata: options.preserveExistingMetadata
+			preserveExistingMetadata
 		});
 		this.sessionManager.clear(session);
 		for (const message of legacyMessages) this.sessionManager.appendEvent(session, {
@@ -4268,19 +4405,647 @@ var NcpAgentSessionStoreAdapter = class {
 		this.sessionManager.save(session);
 		this.options.onSessionUpdated?.(sessionRecord.sessionId);
 	};
+};
+//#endregion
+//#region src/services/ncp-agent-session-store-adapter.service.ts
+function readSessionActivityAt(record) {
+	return record.messages.at(-1)?.timestamp ?? record.createdAt ?? record.updatedAt;
+}
+var NcpAgentSessionStoreAdapter = class {
+	appendSessionEvent;
+	legacyStore;
+	constructor(sessionManager, options = {}) {
+		this.options = options;
+		this.legacyStore = new NcpAgentLegacySessionStore(sessionManager, { onSessionUpdated: options.onSessionUpdated });
+		const journalStore = options.journalStore;
+		if (journalStore) this.appendSessionEvent = async (params) => {
+			const { event, session } = params;
+			if (!await journalStore.hasSession(session.sessionId)) {
+				const legacySession = this.legacyStore.getSession(session.sessionId);
+				if (legacySession) await journalStore.replaceSession(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);
+	};
+	listSessionSummaries = async () => {
+		const journalSummaries = await this.options.journalStore?.listSessionSummaries() ?? [];
+		const journalIds = new Set(journalSummaries.map((summary) => summary.sessionId));
+		const legacySummaries = this.legacyStore.listSessionSummaries().filter((summary) => !journalIds.has(summary.sessionId));
+		return [...journalSummaries, ...legacySummaries].sort((left, right) => readSummaryActivityAt(right).localeCompare(readSummaryActivityAt(left)));
+	};
+	listSessions = async () => {
+		const summaries = await this.listSessionSummaries();
+		const sessions = [];
+		for (const summary of summaries) {
+			const sessionId = summary.sessionId.trim();
+			if (!sessionId) continue;
+			const session = await this.getSession(sessionId);
+			if (!session) continue;
+			sessions.push(session);
+		}
+		sessions.sort((left, right) => readSessionActivityAt(right).localeCompare(readSessionActivityAt(left)));
+		return sessions;
+	};
 	saveSession = async (sessionRecord) => {
-		await this.persistSession(sessionRecord, { preserveExistingMetadata: true });
+		const journalStore = this.options.journalStore;
+		if (journalStore && await journalStore.hasSession(sessionRecord.sessionId)) {
+			await journalStore.replaceSession(sessionRecord);
+			this.options.onSessionUpdated?.(sessionRecord.sessionId);
+			return;
+		}
+		await this.legacyStore.saveSession(sessionRecord);
 	};
 	replaceSession = async (sessionRecord) => {
-		await this.persistSession(sessionRecord, { preserveExistingMetadata: false });
+		const journalStore = this.options.journalStore;
+		if (journalStore && await journalStore.hasSession(sessionRecord.sessionId)) {
+			await journalStore.replaceSession(sessionRecord);
+			this.options.onSessionUpdated?.(sessionRecord.sessionId);
+			return;
+		}
+		await this.legacyStore.replaceSession(sessionRecord);
 	};
 	deleteSession = async (sessionId) => {
-		const existing = await this.getSession(sessionId);
-		if (!existing) return null;
-		this.sessionManager.delete(sessionId);
-		this.options.onSessionUpdated?.(sessionId);
+		const journalSession = await this.options.journalStore?.deleteSession(sessionId);
+		const legacySession = this.legacyStore.deleteSession(sessionId);
+		if (journalSession && !legacySession) this.options.onSessionUpdated?.(sessionId);
+		return journalSession ?? legacySession;
+	};
+};
+function readSummaryActivityAt(summary) {
+	return summary.lastMessageAt ?? summary.createdAt ?? summary.updatedAt;
+}
+function isSessionSummaryRefreshEvent(event) {
+	switch (event.type) {
+		case NcpEventType.MessageSent:
+		case NcpEventType.MessageCompleted:
+		case NcpEventType.MessageAbort:
+		case NcpEventType.RunFinished:
+		case NcpEventType.RunError: return true;
+		default: return false;
+	}
+}
+const NCP_AGENT_SESSION_JOURNAL_INDEX_FILE = ".ncp-agent-session-index.json";
+const AUTO_SESSION_LABEL_MAX_LENGTH = 64;
+function normalizeNcpSessionId(sessionId) {
+	return sessionId.trim();
+}
+function safeNcpSessionFilename(value) {
+	return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function normalizeNcpAgentId(agentId) {
+	const normalized = agentId?.trim().toLowerCase();
+	return normalized ? normalized : 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);
+	return Number.isFinite(parsed) ? new Date(parsed).toISOString() : fallback;
+}
+function createNcpAgentSessionSummary(record) {
+	const metadata = structuredClone(record.metadata ?? {});
+	const label = readOptionalText(metadata.label) ?? resolveAutoSessionLabel(record.messages);
+	if (label) metadata.label = label;
+	const lastMessageAt = readMessageTimestamp(record.messages.at(-1));
+	return {
+		sessionId: record.sessionId,
+		...normalizeNcpAgentId(record.agentId) ? { agentId: normalizeNcpAgentId(record.agentId) } : {},
+		messageCount: record.messages.length,
+		...record.createdAt ? { createdAt: record.createdAt } : {},
+		updatedAt: record.updatedAt,
+		...lastMessageAt ? { lastMessageAt } : {},
+		status: "idle",
+		...Object.keys(metadata).length > 0 ? { metadata } : {}
+	};
+}
+function createNcpAgentSessionJournalMetadataEntry(record) {
+	return {
+		_type: "metadata",
+		version: 1,
+		created_at: record.createdAt ?? record.updatedAt,
+		updated_at: record.updatedAt,
+		...normalizeNcpAgentId(record.agentId) ? { agent_id: normalizeNcpAgentId(record.agentId) } : {},
+		metadata: structuredClone(record.metadata ?? {})
+	};
+}
+function upsertNcpAgentSessionSummaryEvent(params) {
+	const { current, event, session, updatedAt } = params;
+	const metadata = {
+		...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 messageCount = current ? current.messageCount + (eventMessage ? 1 : 0) : eventMessage ? 1 : 0;
+	const lastMessageAt = readMessageTimestamp(eventMessage) ?? current?.lastMessageAt;
+	return {
+		sessionId: session.sessionId,
+		...normalizeNcpAgentId(session.agentId ?? current?.agentId) ? { agentId: normalizeNcpAgentId(session.agentId ?? current?.agentId) } : {},
+		messageCount,
+		createdAt: current?.createdAt ?? session.createdAt ?? updatedAt,
+		updatedAt,
+		...lastMessageAt ? { lastMessageAt } : {},
+		status: "idle",
+		...Object.keys(metadata).length > 0 ? { metadata } : {}
+	};
+}
+async function replayNcpAgentSessionEvents(events) {
+	const stateManager = new DefaultNcpAgentConversationStateManager();
+	for (const event of events) await stateManager.dispatch(event.type === NcpEventType.MessageCompleted ? createCompletedMessageEvent(event) : structuredClone(event));
+	const snapshot = stateManager.getSnapshot();
+	return [...snapshot.messages.map((message) => structuredClone(message)), ...snapshot.streamingMessage ? [structuredClone(snapshot.streamingMessage)] : []];
+}
+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;
+}
+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;
+}
+function resolveAutoSessionLabel(messages) {
+	for (const message of messages) {
+		if (message.role !== "user") continue;
+		for (const part of message.parts) if (part.type === "text" || part.type === "rich-text") {
+			const text = readOptionalText(part.text);
+			if (text) return truncateLabel(text);
+		}
+	}
+	return null;
+}
+function readMessageFromSummaryEvent(event) {
+	switch (event.type) {
+		case NcpEventType.MessageSent: return event.payload.message;
+		case NcpEventType.MessageCompleted: 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-journal.store.ts
+var NcpAgentSessionJournalStore = class {
+	sessions = /* @__PURE__ */ new Map();
+	nextSeqBySession = /* @__PURE__ */ new Map();
+	writeChains = /* @__PURE__ */ new Map();
+	summaryIndex = null;
+	constructor(journalDir) {
+		this.journalDir = journalDir;
+	}
+	appendSessionEvent = async (params) => {
+		const sessionId = normalizeNcpSessionId(params.session.sessionId);
+		if (!sessionId) return;
+		const next = (this.writeChains.get(sessionId) ?? Promise.resolve()).then(() => this.appendSessionEventNow({
+			...params,
+			session: {
+				...params.session,
+				sessionId
+			}
+		}));
+		this.writeChains.set(sessionId, next.catch(() => void 0));
+		await next;
+	};
+	getSession = async (sessionId) => {
+		const normalizedSessionId = normalizeNcpSessionId(sessionId);
+		if (!normalizedSessionId) return null;
+		const cached = this.sessions.get(normalizedSessionId);
+		if (cached) return structuredClone(cached.record);
+		const loaded = await this.loadSession(normalizedSessionId);
+		if (!loaded) return null;
+		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)));
+	};
+	listSessionMessages = async (sessionId) => {
+		const session = await this.getSession(sessionId);
+		return session ? session.messages.map((message) => structuredClone(message)) : [];
+	};
+	replaceSession = async (record) => {
+		const sessionId = normalizeNcpSessionId(record.sessionId);
+		if (!sessionId) return;
+		await this.ensureJournalDir();
+		const nextRecord = structuredClone({
+			...record,
+			sessionId
+		});
+		const entries = [createNcpAgentSessionJournalMetadataEntry(nextRecord), ...nextRecord.messages.map((message, index) => ({
+			_type: "event",
+			version: 1,
+			seq: index + 1,
+			timestamp: message.timestamp ?? nextRecord.updatedAt,
+			event: {
+				type: NcpEventType.MessageSent,
+				payload: {
+					sessionId,
+					message: structuredClone(message)
+				}
+			}
+		}))];
+		await writeFile(this.sessionPath(sessionId), `${entries.map((entry) => JSON.stringify(entry)).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));
+	};
+	deleteSession = async (sessionId) => {
+		const normalizedSessionId = normalizeNcpSessionId(sessionId);
+		if (!normalizedSessionId) return null;
+		const existing = await this.getSession(normalizedSessionId);
+		this.sessions.delete(normalizedSessionId);
+		this.nextSeqBySession.delete(normalizedSessionId);
+		try {
+			await unlink(this.sessionPath(normalizedSessionId));
+		} catch {}
+		await this.removeSummaryIndex(normalizedSessionId);
 		return existing;
 	};
+	hasSession = async (sessionId) => {
+		const normalizedSessionId = normalizeNcpSessionId(sessionId);
+		if (!normalizedSessionId) return false;
+		return (await this.loadSummaryIndex()).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");
+		const entry = {
+			_type: "event",
+			version: 1,
+			seq: nextSeq,
+			timestamp: updatedAt,
+			event: structuredClone(event)
+		};
+		await appendFile(path, `${JSON.stringify(entry)}\n`, "utf-8");
+		this.nextSeqBySession.set(sessionId, nextSeq + 1);
+		this.sessions.delete(sessionId);
+		await this.upsertSummaryIndexForEvent({
+			session,
+			event,
+			updatedAt
+		});
+	};
+	loadSession = async (sessionId) => {
+		let raw;
+		try {
+			raw = await readFile(this.sessionPath(sessionId), "utf-8");
+		} catch {
+			return null;
+		}
+		const { agentId, createdAt, events, metadata, nextSeq, updatedAt } = this.parseSessionJournal(raw);
+		const messages = await replayNcpAgentSessionEvents(events);
+		const record = {
+			sessionId,
+			...agentId ? { agentId } : {},
+			messages,
+			createdAt,
+			updatedAt,
+			metadata
+		};
+		this.nextSeqBySession.set(sessionId, nextSeq);
+		return {
+			record,
+			nextSeq
+		};
+	};
+	parseSessionJournal = (raw) => {
+		let metadata = {};
+		let agentId;
+		let createdAt = (/* @__PURE__ */ new Date()).toISOString();
+		let updatedAt = createdAt;
+		let nextSeq = 1;
+		const events = [];
+		for (const line of raw.split("\n")) {
+			if (!line.trim()) continue;
+			const parsed = JSON.parse(line);
+			if (!isRecord$1(parsed)) continue;
+			if (parsed._type === "metadata") {
+				metadata = isRecord$1(parsed.metadata) ? structuredClone(parsed.metadata) : {};
+				agentId = normalizeNcpAgentId(typeof parsed.agent_id === "string" ? parsed.agent_id : void 0);
+				createdAt = toIsoString(parsed.created_at, createdAt);
+				updatedAt = toIsoString(parsed.updated_at, updatedAt);
+				continue;
+			}
+			if (parsed._type === "event" && isRecord$1(parsed.event)) {
+				const seq = Number(parsed.seq);
+				nextSeq = Math.max(nextSeq, Number.isFinite(seq) ? Math.trunc(seq) + 1 : nextSeq);
+				updatedAt = toIsoString(parsed.timestamp, updatedAt);
+				events.push(structuredClone(parsed.event));
+			}
+		}
+		return {
+			metadata,
+			...agentId ? { agentId } : {},
+			createdAt,
+			updatedAt,
+			nextSeq,
+			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;
+	};
+	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;
+	};
+	upsertSummaryIndex = async (summary) => {
+		(await this.loadSummaryIndex()).set(summary.sessionId, structuredClone(summary));
+		await this.persistSummaryIndex();
+	};
+	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();
+	};
+	removeSummaryIndex = async (sessionId) => {
+		(await this.loadSummaryIndex()).delete(sessionId);
+		await this.persistSummaryIndex();
+	};
+	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");
+	};
+	ensureJournalDir = async () => {
+		await mkdir(this.journalDir, { recursive: true });
+	};
+	sessionPath = (sessionId) => {
+		return join(this.journalDir, `${safeNcpSessionFilename(sessionId.replace(/:/g, "_"))}.jsonl`);
+	};
+	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
+const PREVIEW_TEXT_MAX_LENGTH = 160;
+function readSessionId(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function compactPreviewText(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+function truncatePreviewText(value) {
+	const compacted = compactPreviewText(value);
+	if (compacted.length <= PREVIEW_TEXT_MAX_LENGTH) return compacted;
+	return compacted.slice(0, PREVIEW_TEXT_MAX_LENGTH - 1).trimEnd();
+}
+function readMessagePreviewText(message) {
+	const chunks = [];
+	for (const part of message.parts) if ((part.type === "text" || part.type === "rich-text") && part.text.trim()) chunks.push(part.text);
+	const previewText = truncatePreviewText(chunks.join(" "));
+	return previewText.length > 0 ? previewText : null;
+}
+function createProjection(sessionId, preview) {
+	if (!sessionId) return null;
+	return {
+		sessionId,
+		preview
+	};
+}
+function formatErrorStatus(error) {
+	if (typeof error === "string" && error.trim()) return `运行出错：${truncatePreviewText(error)}`;
+	if (error && typeof error === "object" && "message" in error) {
+		const message = error.message;
+		if (typeof message === "string" && message.trim()) return `运行出错：${truncatePreviewText(message)}`;
+	}
+	return "运行出错";
+}
+function createSessionActivityPreviewFromNcpEvent(event, timestamp) {
+	switch (event.type) {
+		case NcpEventType.RunStarted: return createProjection(readSessionId(event.payload.sessionId), {
+			state: "running",
+			statusText: "正在处理...",
+			timestamp
+		});
+		case NcpEventType.RunFinished: return createProjection(readSessionId(event.payload.sessionId), {
+			state: "completed",
+			timestamp
+		});
+		case NcpEventType.RunError: return createProjection(readSessionId(event.payload.sessionId), {
+			state: "failed",
+			statusText: formatErrorStatus(event.payload.error),
+			timestamp
+		});
+		case NcpEventType.MessageSent: {
+			const text = readMessagePreviewText(event.payload.message);
+			if (!text || event.payload.message.role !== "user") return null;
+			return createProjection(readSessionId(event.payload.sessionId), {
+				state: "running",
+				statusText: text,
+				timestamp: event.payload.message.timestamp || timestamp
+			});
+		}
+		case NcpEventType.MessageCompleted: {
+			const text = readMessagePreviewText(event.payload.message);
+			if (!text || event.payload.message.role !== "assistant") return null;
+			return createProjection(readSessionId(event.payload.sessionId), {
+				state: "completed",
+				replyText: text,
+				timestamp: event.payload.message.timestamp || timestamp
+			});
+		}
+		case NcpEventType.MessageFailed: return createProjection(readSessionId(event.payload.sessionId), {
+			state: "failed",
+			statusText: formatErrorStatus(event.payload.error),
+			timestamp
+		});
+		case NcpEventType.MessageToolCallStart: return createProjection(readSessionId(event.payload.sessionId), {
+			state: "running",
+			statusText: `正在调用工具：${event.payload.toolName}`,
+			timestamp
+		});
+		case NcpEventType.MessageToolCallEnd:
+		case NcpEventType.MessageToolCallResult: return createProjection(readSessionId(event.payload.sessionId), {
+			state: "running",
+			statusText: "工具调用完成",
+			timestamp
+		});
+		default: return null;
+	}
+}
+//#endregion
+//#region src/contributions/session-activity-preview/utils/session-activity-preview-metadata.utils.ts
+const SESSION_ACTIVITY_PREVIEW_METADATA_KEY = "last_activity_preview";
+const SESSION_ACTIVITY_PREVIEW_STATES = new Set([
+	"running",
+	"completed",
+	"failed",
+	"idle"
+]);
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readOptionalString(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function readSessionActivityPreviewMetadata(value) {
+	if (!isRecord(value)) return null;
+	const state = value.state;
+	const timestamp = readOptionalString(value.timestamp);
+	if (!SESSION_ACTIVITY_PREVIEW_STATES.has(state) || !timestamp) return null;
+	return {
+		state,
+		timestamp,
+		...readOptionalString(value.statusText) ? { statusText: readOptionalString(value.statusText) } : {},
+		...readOptionalString(value.replyText) ? { replyText: readOptionalString(value.replyText) } : {}
+	};
+}
+function compareIsoTimestamp(left, right) {
+	const leftTime = Date.parse(left);
+	const rightTime = Date.parse(right);
+	if (!Number.isFinite(leftTime) || !Number.isFinite(rightTime)) return left.localeCompare(right);
+	return leftTime - rightTime;
+}
+function mergeSessionActivityPreview(current, incoming) {
+	if (current && compareIsoTimestamp(incoming.timestamp, current.timestamp) < 0) return current;
+	return {
+		state: incoming.state,
+		timestamp: incoming.timestamp,
+		...incoming.statusText ?? (incoming.state === "completed" ? current?.statusText : void 0) ? { statusText: incoming.statusText ?? current?.statusText } : {},
+		...incoming.replyText ?? current?.replyText ? { replyText: incoming.replyText ?? current?.replyText } : {}
+	};
+}
+function areSessionActivityPreviewsEqual(left, right) {
+	return Boolean(left) && left?.state === right.state && left.timestamp === right.timestamp && left.statusText === right.statusText && left.replyText === right.replyText;
+}
+function writeSessionActivityPreviewMetadata(metadata, projection) {
+	const current = readSessionActivityPreviewMetadata(metadata?.[SESSION_ACTIVITY_PREVIEW_METADATA_KEY]);
+	const next = mergeSessionActivityPreview(current, projection.preview);
+	if (areSessionActivityPreviewsEqual(current, next)) return null;
+	return {
+		...metadata ?? {},
+		[SESSION_ACTIVITY_PREVIEW_METADATA_KEY]: next
+	};
+}
+//#endregion
+//#region src/contributions/session-activity-preview/index.ts
+function formatBackgroundError(error) {
+	if (error instanceof Error) return error.stack ?? error.message;
+	return String(error);
+}
+function readMetadata(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+var SessionActivityPreviewContribution = class {
+	unsubscribeNcpEvent = null;
+	stopped = true;
+	constructor(kernel) {
+		this.kernel = kernel;
+	}
+	start = () => {
+		if (this.unsubscribeNcpEvent) return;
+		this.stopped = false;
+		this.unsubscribeNcpEvent = this.kernel.eventBus.on(eventKeys.ncpEvent, (event) => {
+			const projection = createSessionActivityPreviewFromNcpEvent(event, (/* @__PURE__ */ new Date()).toISOString());
+			if (!projection) return;
+			this.updatePreview(projection);
+		});
+	};
+	dispose = () => {
+		this.unsubscribeNcpEvent?.();
+		this.unsubscribeNcpEvent = null;
+		this.stopped = true;
+	};
+	updatePreview = (projection) => {
+		this.persistPreview(projection).catch((error) => {
+			console.error(`[session-activity-preview] failed to update ${projection.sessionId}: ${formatBackgroundError(error)}`);
+		});
+	};
+	persistPreview = async (projection) => {
+		if (this.stopped) return;
+		const summary = await this.kernel.ncpSessionApi.getSession(projection.sessionId);
+		if (!summary || this.stopped) return;
+		const nextMetadata = writeSessionActivityPreviewMetadata(readMetadata(summary.metadata), projection);
+		if (!nextMetadata) return;
+		await this.kernel.ncpSessionApi.updateSession(projection.sessionId, { metadata: nextMetadata });
+	};
 };
 //#endregion
 //#region src/app/nextclaw-kernel.ts
@@ -4326,7 +5091,8 @@ var NextclawKernel = class {
 	learningLoop;
 	sessionLifecycleEvents;
 	ncpAgentSessionStore;
-	startPromise = null;
+	ncpAgentSessionJournalStore;
+	contributions;
 	constructor(options = {}) {
 		const sessionsDir = resolveKernelSessionsDir(options);
 		this.sessions = new SessionManager({ sessionsDir });
@@ -4336,7 +5102,11 @@ var NextclawKernel = class {
 			sessionsDir,
 			onSessionUpdated: this.publishSessionUpdated
 		});
-		this.ncpAgentSessionStore = new NcpAgentSessionStoreAdapter(this.sessions, { onSessionUpdated: this.sessionSearch.handleSessionUpdated });
+		this.ncpAgentSessionJournalStore = new NcpAgentSessionJournalStore(resolve(sessionsDir, ".ncp-agent-journal"));
+		this.ncpAgentSessionStore = new NcpAgentSessionStoreAdapter(this.sessions, {
+			journalStore: this.ncpAgentSessionJournalStore,
+			onSessionUpdated: this.sessionSearch.handleSessionUpdated
+		});
 		this.sessionRequests = new SessionRequestManager({
 			sessions: this.sessions,
 			dispatcher: createAgentRuntimeSessionRequestDispatcher({
@@ -4360,11 +5130,6 @@ var NextclawKernel = class {
 			channels: this.channels,
 			providerManager: this.llmProviders
 		});
-		this.ncpSessionApi = new NcpSessionApiService({
-			eventBus: this.eventBus,
-			getConfig: this.configManager.loadConfig,
-			sessionManager: this.sessions
-		});
 		this.agentRuntimeManager = new AgentRuntimeManager({
 			bus: this.messageBus,
 			providerManager: this.llmProviders,
@@ -4381,30 +5146,34 @@ var NextclawKernel = class {
 			llmUsage: this.llmUsage,
 			onSessionUpdated: this.publishSessionUpdated
 		});
+		this.ncpSessionApi = new NcpSessionApiService({
+			eventBus: this.eventBus,
+			getConfig: this.configManager.loadConfig,
+			isLiveSessionRunning: this.agentRuntimeManager.isLiveSessionRunning,
+			ncpAgentSessionStore: this.ncpAgentSessionStore,
+			sessionManager: this.sessions
+		});
 		this.learningLoop = new LearningLoopManager({
 			eventBus: this.eventBus,
 			sessionManager: this.sessions,
 			sessionRequester: this.sessionRequests,
 			resolveLearningLoopConfig: () => readLearningLoopRuntimeConfig(this.configManager.loadConfig())
 		});
+		this.contributions = [new SessionActivityPreviewContribution(this)];
 	}
 	start = async () => {
-		this.startPromise ??= Promise.resolve().then(() => {
-			this.ncpSessionApi.start();
-		}).then(() => this.sessionSearch.start()).then(() => this.agentRuntimeManager.bootstrap()).then(() => {
-			this.learningLoop.start();
-		}).catch((error) => {
-			this.startPromise = null;
-			throw error;
-		});
-		return this.startPromise;
+		this.ncpSessionApi.start();
+		this.sessionSearch.start();
+		for (const contribution of this.contributions) contribution.start();
+		this.agentRuntimeManager.bootstrap();
+		this.learningLoop.start();
 	};
 	dispose = async () => {
 		this.learningLoop.dispose();
+		for (const contribution of this.contributions) contribution.dispose();
 		this.ncpSessionApi.dispose();
 		await this.agentRuntimeManager.dispose();
 		await this.sessionSearch.dispose();
-		this.startPromise = null;
 	};
 	publishSessionUpdated = (sessionKey) => {
 		this.sessionLifecycleEvents.publishSessionUpdated(sessionKey);