@nextclaw/kernel 0.1.3 → 0.1.5

package/dist/index.d.ts

@@ -279,6 +279,7 @@ type AgentRuntimeHandle = AgentRuntimeEndpoint & {
 };
 declare function createAgentRuntimeHandle(params: {
   backend: DefaultNcpAgentBackend;
+  agentClientEndpoint?: NcpAgentClientEndpoint;
   runtimeRegistry: AgentRuntimeRegistry;
   refreshPluginRuntimeRegistrations: () => void;
   refreshConfiguredRuntimeEntries: () => void;
@@ -495,6 +496,8 @@ declare class AgentRuntimeManager {
   get currentHandle(): AgentRuntimeHandle | null;
   connectGatewayController: (gatewayController: GatewayController) => void;
   bootstrap: () => Promise<AgentRuntimeHandle>;
+  private readonly materializeAgentSendEnvelope;
+  private readonly createMaterializingAgentClientEndpoint;
   warmDerivedCapabilities: () => Promise<void>;
   dispose: () => Promise<void>;
   private readonly registerCoreRuntimes;
@@ -653,9 +656,14 @@ declare class ToolManager {
 }
 //#endregion
 //#region src/services/ncp-session-api.service.d.ts
+type NcpAgentSessionReadableStore = AgentSessionStore & {
+  listSessionSummaries?: () => Promise<NcpSessionSummary[]>;
+  listSessionMessages?: (sessionId: string) => Promise<NcpMessage[]>;
+};
 type NcpSessionApiServiceOptions = {
   eventBus: EventBus;
   getConfig: () => Config;
+  ncpAgentSessionStore?: NcpAgentSessionReadableStore;
   sessionManager: SessionManager;
 };
 declare class NcpSessionApiService implements NcpSessionApi {
@@ -713,6 +721,7 @@ declare class NextclawKernel {
   readonly learningLoop: LearningLoopManager;
   private readonly sessionLifecycleEvents;
   private readonly ncpAgentSessionStore;
+  private readonly ncpAgentSessionJournalStore;
   private startPromise;
   constructor(options?: NextclawKernelOptions);
   start: () => Promise<void>;
@@ -952,6 +961,7 @@ declare function createNcpSessionSummary(params: {
   sessionId: string;
   agentId?: string;
   messages: readonly NcpMessage[];
+  createdAt: string;
   updatedAt: string;
   status: NcpSessionStatus;
   metadata?: Record<string, unknown>;

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$4(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function cloneMetadata(value) {
-	return isRecord$3(value) ? structuredClone(value) : void 0;
+	return isRecord$4(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$3(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$3(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$3(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$3(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$3(args.path);
+		const bytesBase64 = readOptionalString$3(args.bytesBase64);
+		const fileName = readOptionalString$3(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$3(args?.path);
+		const fileName = readOptionalString$3(args?.fileName);
+		const mimeType = readOptionalString$3(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$3(args?.assetUri);
+		const targetPath = readOptionalString$3(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$3(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$2(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$2(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$2(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$1(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$1(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$1(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$1(rawTitle),
+			agentId: readOptionalString$1(rawAgentId),
+			model: readOptionalString$1(rawModel),
+			runtime: readOptionalString$1(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$1(rawTitle),
 			sourceSessionMetadata: this.sourceSessionMetadata,
-			agentId: readOptionalString(rawAgentId),
-			model: readOptionalString(rawModel),
-			runtime: readOptionalString(rawRuntime),
+			agentId: readOptionalString$1(rawAgentId),
+			model: readOptionalString$1(rawModel),
+			runtime: readOptionalString$1(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$4(args)) return args;
 	if (typeof args === "string") try {
 		const parsed = JSON.parse(args);
-		return isRecord$3(parsed) ? parsed : {};
+		return isRecord$4(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$2(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$2(message.metadata))?.metadata;
 	return {
-		...isRecord$1(messageMetadata) ? structuredClone(messageMetadata) : {},
-		...isRecord$1(input.metadata) ? structuredClone(input.metadata) : {}
+		...isRecord$2(messageMetadata) ? structuredClone(messageMetadata) : {},
+		...isRecord$2(input.metadata) ? structuredClone(input.metadata) : {}
 	};
 }
 const REQUESTED_SKILLS_METADATA_READER = new RequestedSkillsMetadataReader();
@@ -2978,12 +2978,12 @@ function createContextWindowUpdatedEvent(params) {
 		}
 	};
 }
-function isRecord(value) {
+function isRecord$1(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$1(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(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(metadata?.[key]);
+		if (value) return value;
+	}
+}
+async function consumeAgentEvents(events) {
+	for await (const event of events);
+}
 var AgentRuntimeManager = class {
 	runtimeRegistry = new AgentRuntimeRegistry();
 	mcpRuntimeSupport;
@@ -3321,6 +3339,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 +3349,68 @@ var AgentRuntimeManager = class {
 		});
 		return this.handle;
 	};
+	materializeAgentSendEnvelope = (envelope) => {
+		const existingSessionId = readOptionalString(envelope.sessionId) ?? readOptionalString(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 +4150,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 +4182,28 @@ function buildUpdatedMetadata(params) {
 function normalizeSessionId(sessionId) {
 	return sessionId.trim();
 }
+function toSessionCandidate(record) {
+	const sessionId = normalizeSessionId(record.key);
+	return sessionId ? {
+		...record,
+		sessionId
+	} : null;
+}
+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)
+	};
+}
+function readSessionActivityAt$1(record) {
+	return record.lastMessageAt ?? record.created_at;
+}
 var NcpSessionApiService = class {
 	unsubscribeSessionUpdated = null;
 	contextWindowPreview;
@@ -4133,32 +4237,36 @@ 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);
+		return applyLimit(this.options.sessionManager.listSessions().map(toSessionCandidate).filter((record) => Boolean(record)).sort((left, right) => readSessionActivityAt$1(right).localeCompare(readSessionActivityAt$1(left))), options?.limit).map(createSessionListSummary);
 	};
 	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 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);
@@ -4166,6 +4274,7 @@ var NcpSessionApiService = class {
 			sessionId: normalizedSessionId,
 			agentId: session.agentId,
 			messages,
+			createdAt: session.createdAt.toISOString(),
 			updatedAt: session.updatedAt.toISOString(),
 			status: "idle",
 			metadata: session.metadata,
@@ -4179,6 +4288,21 @@ var NcpSessionApiService = class {
 	};
 	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,6 +4317,7 @@ 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);
 	};
@@ -4205,58 +4330,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 +4407,457 @@ 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(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(parsed)) continue;
+			if (parsed._type === "metadata") {
+				metadata = isRecord(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(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/app/nextclaw-kernel.ts
@@ -4326,6 +4903,7 @@ var NextclawKernel = class {
 	learningLoop;
 	sessionLifecycleEvents;
 	ncpAgentSessionStore;
+	ncpAgentSessionJournalStore;
 	startPromise = null;
 	constructor(options = {}) {
 		const sessionsDir = resolveKernelSessionsDir(options);
@@ -4336,7 +4914,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({
@@ -4363,6 +4945,7 @@ var NextclawKernel = class {
 		this.ncpSessionApi = new NcpSessionApiService({
 			eventBus: this.eventBus,
 			getConfig: this.configManager.loadConfig,
+			ncpAgentSessionStore: this.ncpAgentSessionStore,
 			sessionManager: this.sessions
 		});
 		this.agentRuntimeManager = new AgentRuntimeManager({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/kernel",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "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/mcp": "0.1.79",
-    "@nextclaw/ncp-http-agent-server": "0.3.19",
-    "@nextclaw/ncp-mcp": "0.1.81",
-    "@nextclaw/core": "0.12.14",
-    "@nextclaw/nextclaw-ncp-runtime-http-client": "0.1.6",
-    "@nextclaw/nextclaw-hermes-acp-bridge": "0.1.6",
-    "@nextclaw/openclaw-compat": "1.0.14",
-    "@nextclaw/ncp-agent-runtime": "0.3.17",
-    "@nextclaw/runtime": "0.2.46",
-    "@nextclaw/shared": "0.1.1",
-    "@nextclaw/ncp": "0.5.7",
-    "@nextclaw/ncp-toolkit": "0.5.12",
-    "@nextclaw/nextclaw-ncp-runtime-stdio-client": "0.1.7"
+    "@nextclaw/core": "0.12.16",
+    "@nextclaw/ncp-http-agent-server": "0.3.21",
+    "@nextclaw/mcp": "0.1.81",
+    "@nextclaw/ncp-agent-runtime": "0.3.19",
+    "@nextclaw/ncp-mcp": "0.1.83",
+    "@nextclaw/ncp-toolkit": "0.5.14",
+    "@nextclaw/nextclaw-ncp-runtime-http-client": "0.1.8",
+    "@nextclaw/nextclaw-ncp-runtime-stdio-client": "0.1.9",
+    "@nextclaw/nextclaw-hermes-acp-bridge": "0.1.8",
+    "@nextclaw/openclaw-compat": "1.0.16",
+    "@nextclaw/shared": "0.1.3",
+    "@nextclaw/runtime": "0.2.48",
+    "@nextclaw/ncp": "0.5.9"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",