@nextclaw/kernel 0.6.10 → 0.6.11

package/dist/index.js

@@ -2,15 +2,15 @@ import { AUTOMATIC_UPDATE_CHECK_INTERVAL_MS, getAutomaticUpdateCheckDelay, resol
 import { n as getUnsignedUpdateManifest, r as serializeUnsignedUpdateManifest, t as UpdateManifestReader } from "./update-manifest.types-C0qPrjGQ.js";
 import { createRequire } from "node:module";
 import { APP_NAME, AgentRouteResolver, BUILTIN_MAIN_AGENT_ID, CLEAR_THINKING_TOKENS, CONTEXT_COMPACTION_METADATA_KEY, ConfigSchema, ContextCompactionService, ContextWindowBudgetService, CronService, CronTool, DEFAULT_PANELS_DIR, DEFAULT_SERVICE_APPS_DIR, DEFAULT_SESSION_SEARCH_LIMIT, DEFAULT_WORKSPACE_REPOSITORY_IDENTITY_RESOLVER, EditFileTool, ExecTool, ExtensionChannelAdapter, GatewayTool, InputBudgetPruner, LLMProvider, ListDirTool, LiteLLMProvider, MAX_SESSION_SEARCH_LIMIT, MemoryGetTool, MemorySearchTool, MemoryStore, MessageBus, MessageTool, ProviderRegistry, ReadFileTool, RequestedSkillsMetadataReader, SILENT_REPLY_TOKEN, SessionProjectContextResolver, SessionSearchService, SkillsLoader, THINKING_LEVELS, ViewImageTool, WebFetchTool, WebSearchTool, WriteFileTool, buildCompressingCompactionCheckpoint, buildConfigSchema, buildContextWindowSnapshot, buildReloadPlan, buildSessionRequestToolResult, buildToolCatalogEntries, createAgentProfile, createAssistantStreamDeltaControlMessage, createAssistantStreamResetControlMessage, createCompletedSessionRequest, createFailedSessionRequest, createRunningSessionRequest, createRuntimeChildEnv, createTypingStopControlMessage, diffConfigPaths, ensureDir, evaluateSilentReply, expandHome, findEffectiveAgentProfile, getConfigPath, getDataDir, getDataPath, getSessionsPath, getWorkspacePath, getWorkspacePathFromConfig, isNextclawControlMessage, loadConfig, mergeExtensionConfigView, modelSupportsVision, normalizeAgentProfileId, normalizeInlineSecretRefs, normalizeModelThinkingCapability, normalizeProviderModelConfig, normalizeToolParams, parseAgentScopedSessionKey, parseThinkingLevel, readCompressedContextCompactionCheckpoint, readOptionalString, readParentSessionId, readSessionProjectRoot, redactConfigObject, removeAgentProfile, resolveConfigSecrets, resolveDefaultAgentProfileId, resolveEffectiveAgentProfiles, resolveNextclawSelfManageGuidePaths, resolveProviderRuntime, resolveSessionProjectContext, resolveSessionWorkspacePath, resolveThinkingLevel, safeFilename, sanitizeOutboundAssistantContent, saveConfig, summarizeSessionRequestTask, toExtensionConfigView, updateAgentProfile } from "@nextclaw/core";
-import { NcpEventType, normalizeAssistantText, sanitizeAssistantReplyTags } from "@nextclaw/ncp";
+import { NCP_AI_EXECUTION_METADATA_KEY, NcpEventType, createUnavailableNcpAiExecutionMetadata, normalizeAssistantText, readNcpAiExecutionMetadata, sanitizeAssistantReplyTags } from "@nextclaw/ncp";
 import { LocalAssetStore, buildAssetContentPath, buildNcpUserContent, buildOpenAiFunctionTool, ncpMessageToOpenAiMessages, validateToolArgs } from "@nextclaw/ncp-agent-runtime";
 import { createHash, createHmac, randomBytes, randomUUID, scryptSync, timingSafeEqual } from "node:crypto";
-import { CHAT_INLINE_TOKENS_METADATA_KEY, CHAT_SESSION_MATERIALIZATION_METADATA_KEY, CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND, CHAT_WORKSPACE_FILE_TOKEN_KIND, EventBus, Ingress, eventKeys, ingressKeys, isRuntimeDefaultModelValue, normalizeRuntimeModelSelectionMode } from "@nextclaw/shared";
+import { CHAT_INLINE_TOKENS_METADATA_KEY, CHAT_SESSION_MATERIALIZATION_METADATA_KEY, CHAT_WORKSPACE_DIRECTORY_TOKEN_KIND, CHAT_WORKSPACE_FILE_TOKEN_KIND, EventBus, Ingress, PANEL_APP_INLINE_HOST_CONTRACT, eventKeys, ingressKeys, isRuntimeDefaultModelValue, normalizeRuntimeModelSelectionMode, readInlineContentHeight } from "@nextclaw/shared";
 import { catchError, from, lastValueFrom, tap } from "rxjs";
 import { appendFileSync, chmodSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
 import { execFileSync, spawn } from "node:child_process";
-import { access, appendFile, mkdir, open, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { access, appendFile, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { BUILTIN_PROVIDER_PLUGINS } from "@nextclaw/runtime";
 import { McpRegistryService, McpServerLifecycleManager } from "@nextclaw/mcp";
@@ -658,6 +658,32 @@ const AGENT_RUN_EXECUTION_METADATA = {
 		}
 	}
 };
+function readAgentRunStartedAt(event, fallback) {
+	if (event.type !== NcpEventType.RunStarted) return fallback;
+	return event.payload.startedAt ?? event.occurredAt ?? fallback;
+}
+function hasAiExecutionMetadata(event) {
+	return event.type === NcpEventType.RunMetadata && Boolean(readNcpAiExecutionMetadata(event.payload.metadata));
+}
+function createUnavailableAiExecutionMetadataEvent(params) {
+	const { sessionId, spec } = params;
+	return {
+		occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+		type: NcpEventType.RunMetadata,
+		payload: {
+			runId: spec.runId,
+			sessionId,
+			correlationId: spec.correlationId,
+			metadata: { [NCP_AI_EXECUTION_METADATA_KEY]: createUnavailableNcpAiExecutionMetadata({
+				runId: spec.runId,
+				runtimeId: spec.runtimeId,
+				model: spec.model,
+				requestedModel: spec.requestedModel,
+				outcome: "failed"
+			}) }
+		}
+	};
+}
 //#endregion
 //#region src/managers/agent-run-request.manager.ts
 function toAgentRunRequest(envelope) {
@@ -717,10 +743,6 @@ function readOptionalString$11(value) {
 	if (typeof value !== "string") return;
 	return value.trim() || void 0;
 }
-function readRunStartedAt(event, fallback) {
-	if (event.type !== NcpEventType.RunStarted) return fallback;
-	return event.payload.startedAt ?? event.occurredAt ?? fallback;
-}
 function createCompletedAssistantMessageEvent(params) {
 	return {
 		occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -781,12 +803,15 @@ function resolveRunSpec(params) {
 	const { agentManager, configManager, request, runId, session } = params;
 	const modelSource = request.model !== void 0 ? "request" : session.model !== void 0 ? "session" : "default";
 	const model = request.model ?? session.model ?? configManager.getDefaultModel();
+	const agentId = request.agentId ?? session.agentId ?? agentManager.getDefaultAgentId();
 	return {
 		modelSource,
 		spec: {
 			runId,
-			agentId: request.agentId ?? session.agentId ?? agentManager.getDefaultAgentId(),
+			runtimeId: session.agentRuntimeId,
+			agentId,
 			model,
+			requestedModel: request.model ?? null,
 			maxTokens: request.maxTokens ?? configManager.getModelMaxTokens(model),
 			thinkingEffort: request.thinkingEffort ?? session.thinkingEffort ?? null,
 			correlationId: request.correlationId
@@ -921,19 +946,37 @@ var AgentRunRequestManager = class {
 		});
 		const contextBlocks = await this.contextProviderManager.buildContext(providerRequest);
 		const tools = await this.toolProviderManager.buildTools(providerRequest);
+		this.startRuntimeRun({
+			options: {
+				contextBlocks,
+				session,
+				sessionRun,
+				signal: activeRun.signal,
+				tools
+			},
+			requestRunStartedAt,
+			runtime,
+			spec
+		});
+		return {
+			sessionId: session.sessionId,
+			userMessageId: message.id,
+			runId: spec.runId,
+			correlationId: request.correlationId
+		};
+	};
+	startRuntimeRun = (params) => {
+		const { options, requestRunStartedAt, runtime, spec } = params;
+		const { session, sessionRun } = options;
 		let messageCompletedSeen = false;
+		let executionMetadataSeen = false;
 		let runtimeFailed = false;
 		let runStartedAt = requestRunStartedAt;
-		lastValueFrom(from(runtime.run(spec, {
-			contextBlocks,
-			session,
-			sessionRun,
-			signal: activeRun.signal,
-			tools
-		})).pipe(tap((event) => {
+		lastValueFrom(from(runtime.run(spec, options)).pipe(tap((event) => {
 			const eventsToPublish = [];
 			if (event.type === NcpEventType.RunError) runtimeFailed = true;
-			runStartedAt = readRunStartedAt(event, runStartedAt);
+			if (hasAiExecutionMetadata(event)) executionMetadataSeen = true;
+			runStartedAt = readAgentRunStartedAt(event, runStartedAt);
 			if (event.type === NcpEventType.MessageCompleted) messageCompletedSeen = true;
 			if (event.type === NcpEventType.RunFinished && !messageCompletedSeen) {
 				const message = findCompletedAssistantMessage(sessionRun.getSnapshot().messages, event.payload.messageId);
@@ -952,6 +995,17 @@ var AgentRunRequestManager = class {
 			});
 		}), catchError(async (error) => {
 			runtimeFailed = true;
+			if (!executionMetadataSeen) {
+				const metadataEvent = createUnavailableAiExecutionMetadataEvent({
+					spec,
+					sessionId: session.sessionId
+				});
+				await sessionRun.applyEvents([metadataEvent]);
+				this.eventBus.emit(eventKeys.ncpEvent, metadataEvent, {
+					emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					source: "agent-run-request"
+				});
+			}
 			const event = createSyntheticRunErrorEvent({
 				error,
 				runId: spec.runId,
@@ -972,12 +1026,6 @@ var AgentRunRequestManager = class {
 				sessionRun
 			}).catch(() => void 0);
 		});
-		return {
-			sessionId: session.sessionId,
-			userMessageId: message.id,
-			runId: spec.runId,
-			correlationId: request.correlationId
-		};
 	};
 	getOrCreateSessionForRequest = async (request) => {
 		const sessionMaterialization = readSessionMaterialization(request.metadata ?? {});
@@ -1031,14 +1079,24 @@ function normalizeAgentRuntimeSessionTypeIcon(value) {
 		...alt ? { alt } : {}
 	};
 }
-const BUILTIN_RUNTIME_PRESENTATION = { hermes: {
-	label: "Hermes",
-	icon: {
-		kind: "image",
-		src: "app://runtime-icons/hermes-agent.png",
-		alt: "Hermes"
+const BUILTIN_RUNTIME_PRESENTATION = {
+	hermes: {
+		label: "Hermes",
+		icon: {
+			kind: "image",
+			src: "app://runtime-icons/hermes-agent.png",
+			alt: "Hermes"
+		}
+	},
+	opencode: {
+		label: "OpenCode",
+		icon: {
+			kind: "image",
+			src: "app://runtime-icons/opencode.svg",
+			alt: "OpenCode"
+		}
 	}
-} };
+};
 function readString$7(value) {
 	if (typeof value !== "string") return;
 	return value.trim() || void 0;
@@ -3665,16 +3723,24 @@ function upsertNcpAgentSessionSummaryEvent(params) {
 		status: "idle"
 	};
 }
-async function replayNcpAgentSessionEvents(events) {
+async function replayNcpAgentSessionEvents(events, seedMessages = []) {
 	const stateManager = new DefaultNcpAgentConversationStateManager();
-	const knownMessageIds = /* @__PURE__ */ new Set();
+	if (seedMessages.length > 0) stateManager.hydrate({
+		sessionId: seedMessages[0]?.sessionId ?? "",
+		messages: seedMessages
+	});
+	const knownMessageIds = new Set(seedMessages.map((message) => message.id));
 	const toolResultsByCallId = /* @__PURE__ */ new Map();
 	for (const event of events) {
 		if (isJournalOnlyEvent(event)) continue;
 		const replayEvent = createReplayEvent(event, toolResultsByCallId);
-		const bootstrapEvent = createReplayStreamingBootstrapEvent(replayEvent, knownMessageIds);
-		if (bootstrapEvent) await stateManager.dispatch(bootstrapEvent);
-		rememberReplayMessageId(replayEvent, knownMessageIds);
+		const bootstrap = createReplayStreamingBootstrapEvent(replayEvent, knownMessageIds);
+		if (bootstrap) {
+			knownMessageIds.add(bootstrap.messageId);
+			await stateManager.dispatch(bootstrap.event);
+		}
+		const replayMessageId = readReplayMessageId(replayEvent);
+		if (replayMessageId) knownMessageIds.add(replayMessageId);
 		await stateManager.dispatch(replayEvent);
 		if (replayEvent.type === NcpEventType.MessageToolCallResult) toolResultsByCallId.set(replayEvent.payload.toolCallId, replayEvent.payload);
 	}
@@ -3731,26 +3797,27 @@ function readLegacyContextCompactionMessageId(message) {
 function createReplayStreamingBootstrapEvent(event, knownMessageIds) {
 	const messageId = readStreamingMessageId(event);
 	if (!messageId || knownMessageIds.has(messageId)) return null;
-	knownMessageIds.add(messageId);
 	return {
-		occurredAt: event.occurredAt,
-		type: NcpEventType.MessageSent,
-		payload: {
-			sessionId: readEventSessionId$2(event),
-			message: {
-				id: messageId,
+		messageId,
+		event: {
+			occurredAt: event.occurredAt,
+			type: NcpEventType.MessageSent,
+			payload: {
 				sessionId: readEventSessionId$2(event),
-				role: "assistant",
-				status: "streaming",
-				parts: [],
-				timestamp: readReplayPayloadTimestamp(event) ?? (/* @__PURE__ */ new Date()).toISOString()
+				message: {
+					id: messageId,
+					sessionId: readEventSessionId$2(event),
+					role: "assistant",
+					status: "streaming",
+					parts: [],
+					timestamp: readReplayPayloadTimestamp(event) ?? (/* @__PURE__ */ new Date()).toISOString()
+				}
 			}
 		}
 	};
 }
-function rememberReplayMessageId(event, knownMessageIds) {
-	const message = readMessageFromSummaryEvent(event);
-	if (message?.id) knownMessageIds.add(message.id);
+function readReplayMessageId(event) {
+	return readMessageFromSummaryEvent(event)?.id ?? null;
 }
 function readEventSessionId$2(event) {
 	const sessionId = ("payload" in event && isRecord$11(event.payload) ? event.payload : null)?.sessionId;
@@ -3805,6 +3872,15 @@ function readMessageFromSummaryEvent(event) {
 }
 //#endregion
 //#region src/types/session.types.ts
+var SessionMessageCursorError = class extends Error {
+	constructor(message = "Invalid session message cursor.") {
+		super(message);
+		this.name = "SessionMessageCursorError";
+	}
+};
+function isSessionMessageCursorError(error) {
+	return error instanceof SessionMessageCursorError;
+}
 var SessionSettingsError = class extends Error {
 	constructor(code, message) {
 		super(message);
@@ -4502,13 +4578,40 @@ var SessionManager = class {
 		return applyLimit((await this.options.journalStore.listSessionSummaries()).filter((summary) => !peerId || summary.peerId === peerId).map(this.workingDirResolver.withWorkingDir), options?.limit);
 	};
 	listSessionMessages = async (sessionId, options) => {
+		const { cursor, limit } = options ?? {};
 		const normalizedSessionId = normalizeSessionId(sessionId);
 		if (!normalizedSessionId) return [];
-		return applyLimit(await this.options.journalStore.listSessionMessages(normalizedSessionId), options?.limit);
+		if (limit !== void 0 || cursor) return (await this.listSessionMessagePage(normalizedSessionId, {
+			limit: limit ?? 200,
+			...cursor ? { cursor } : {}
+		}))?.messages ?? [];
+		return await this.options.journalStore.listSessionMessages(normalizedSessionId);
+	};
+	listSessionMessagePage = async (sessionId, options) => {
+		const { cursor, limit } = options;
+		const normalizedSessionId = normalizeSessionId(sessionId);
+		if (!normalizedSessionId) return null;
+		const page = await this.options.journalStore.listSessionMessagePage({
+			sessionId: normalizedSessionId,
+			limit,
+			...cursor ? { cursor } : {}
+		});
+		if (!page || page.contextWindow) return page;
+		const record = await this.options.journalStore.getSession(normalizedSessionId);
+		if (!record) return page;
+		const contextWindow = this.createSummaryFromRecord(record, true).contextWindow ?? null;
+		await this.options.journalStore.updateSessionMessageProjectionContextWindow(normalizedSessionId, contextWindow);
+		return {
+			...page,
+			contextWindow
+		};
 	};
 	getSession = async (sessionId) => {
 		const record = await this.getSessionRecord(sessionId);
-		return record ? this.createSummaryFromRecord(record, true) : null;
+		if (!record) return null;
+		const summary = this.createSummaryFromRecord(record, true);
+		await this.options.journalStore.updateSessionMessageProjectionContextWindow(record.sessionId, summary.contextWindow ?? null);
+		return summary;
 	};
 	getContextWindow = async (sessionId, liveRecord) => {
 		return (liveRecord ? this.createSummaryFromRecord(liveRecord, true) : await this.getSession(sessionId))?.contextWindow ?? null;
@@ -5369,6 +5472,51 @@ var PanelAppAgentBridgeService = class {
 //#endregion
 //#region src/utils/panel-app-bridge.utils.ts
 const PANEL_APP_BRIDGE_MARKER = "nextclaw:panel-app-service-actions:request";
+function getPanelAppInlineContentHeightReporterScript() {
+	return `
+  function installInlineContentHeightReporter() {
+    const inlineHostContract = ${JSON.stringify(PANEL_APP_INLINE_HOST_CONTRACT)};
+    const readInlineContentHeight = ${readInlineContentHeight.toString()};
+    if (!window.location || !window.document) {
+      return;
+    }
+    const searchParams = new URLSearchParams(window.location.search);
+    if (
+      searchParams.get(inlineHostContract.displayModeSearchParam) !== inlineHostContract.displayMode ||
+      searchParams.get(inlineHostContract.placementSearchParam) !== inlineHostContract.placement
+    ) {
+      return;
+    }
+    const start = () => {
+      const { body, documentElement } = window.document;
+      if (!documentElement) {
+        return;
+      }
+      let lastHeight = 0;
+      const reportHeight = () => {
+        const height = readInlineContentHeight(body, documentElement);
+        if (height > 0 && height !== lastHeight) {
+          lastHeight = height;
+          window.parent.postMessage({ type: inlineHostContract.contentHeightMessageType, height }, "*");
+        }
+      };
+      if (typeof window.ResizeObserver === "function") {
+        const observer = new window.ResizeObserver(reportHeight);
+        observer.observe(documentElement);
+        if (body) {
+          observer.observe(body);
+        }
+      }
+      window.addEventListener("load", reportHeight);
+      reportHeight();
+    };
+    if (window.document.readyState === "loading") {
+      window.document.addEventListener("DOMContentLoaded", start, { once: true });
+      return;
+    }
+    start();
+  }`.trim();
+}
 function injectPanelAppBridgeScript(html, params) {
 	if (html.includes(PANEL_APP_BRIDGE_MARKER)) return html;
 	const script = `<script>${getPanelAppBridgeScript(params)}<\/script>`;
@@ -5405,6 +5553,8 @@ function getPanelAppBridgeScript(params = {
     });
   }
 
+  ${getPanelAppInlineContentHeightReporterScript()}
+
   function resolveApiFetchUrl(input) {
     const raw = typeof input === "string" || input instanceof URL ? input.toString() : input?.url;
     if (typeof raw !== "string") {
@@ -5502,6 +5652,7 @@ function getPanelAppBridgeScript(params = {
       }
     }
   });
+  installInlineContentHeightReporter();
 })();
 `.trim();
 }
@@ -7425,6 +7576,90 @@ function resolveAgentHandoffDepth(metadata) {
 	return Math.trunc(rawDepth);
 }
 //#endregion
+//#region src/utils/ncp-agent-session-journal-entry.utils.ts
+function isNcpAgentSessionMessageProjectionBoundaryEvent(event) {
+	return event.type === NcpEventType.MessageSent || event.type === NcpEventType.MessageCompleted || event.type === NcpEventType.MessageAbort || event.type === NcpEventType.RunFinished || event.type === NcpEventType.RunError || event.type === "session.snapshot.message";
+}
+function serializeNcpAgentSessionJournalEntry(entry) {
+	const serialized = JSON.stringify(entry);
+	if (!serialized) throw new Error("ncp agent session journal entry serialization produced empty output");
+	if (!isRecord$11(JSON.parse(serialized))) throw new Error("ncp agent session journal entry serialization produced a non-object entry");
+	return serialized;
+}
+function attachNcpAgentSessionJournalTimestamp(event, timestamp) {
+	if (!("payload" in event) || !isRecord$11(event.payload)) return event;
+	return {
+		...event,
+		payload: {
+			...event.payload,
+			timestamp
+		}
+	};
+}
+var NcpAgentSessionJournalParser = class {
+	metadata = {};
+	agentId;
+	createdAt = (/* @__PURE__ */ new Date()).toISOString();
+	updatedAt = this.createdAt;
+	nextSeq = 1;
+	projectedJournalOffset = 0;
+	events = [];
+	append = (line, index, lineEndOffset) => {
+		if (!line.trim()) return;
+		const parsed = this.parseLine(line, index);
+		if (!parsed) return;
+		if (parsed._type === "metadata") {
+			this.applyMetadata(parsed);
+			return;
+		}
+		if (parsed._type === "event" && isRecord$11(parsed.event)) this.applyEvent(parsed, lineEndOffset);
+	};
+	finish = () => ({
+		metadata: this.metadata,
+		...this.agentId ? { agentId: this.agentId } : {},
+		createdAt: this.createdAt,
+		updatedAt: this.updatedAt,
+		nextSeq: this.nextSeq,
+		projectedJournalOffset: this.projectedJournalOffset,
+		events: this.events
+	});
+	parseLine = (line, index) => {
+		try {
+			const parsed = JSON.parse(line);
+			return isRecord$11(parsed) ? parsed : null;
+		} catch (error) {
+			console.warn(`[ncp-agent-session-journal] skipped corrupted journal line ${index + 1}: ${error instanceof Error ? error.message : String(error)}`);
+			return null;
+		}
+	};
+	applyMetadata = (entry) => {
+		this.metadata = isRecord$11(entry.metadata) ? structuredClone(entry.metadata) : {};
+		this.agentId = normalizeNcpAgentId(typeof entry.agent_id === "string" ? entry.agent_id : void 0);
+		this.createdAt = toIsoString(entry.created_at, this.createdAt);
+		this.updatedAt = toIsoString(entry.updated_at, this.updatedAt);
+	};
+	applyEvent = (entry, lineEndOffset) => {
+		const seq = Number(entry.seq);
+		this.nextSeq = Math.max(this.nextSeq, Number.isFinite(seq) ? Math.trunc(seq) + 1 : this.nextSeq);
+		const eventTimestamp = toIsoString(entry.timestamp, this.updatedAt);
+		this.updatedAt = eventTimestamp;
+		const replayEvent = attachNcpAgentSessionJournalTimestamp(structuredClone(entry.event), eventTimestamp);
+		this.events.push(replayEvent);
+		if (isNcpAgentSessionMessageProjectionBoundaryEvent(replayEvent)) this.projectedJournalOffset = lineEndOffset;
+	};
+};
+function parseNcpAgentSessionJournal(raw) {
+	const parser = new NcpAgentSessionJournalParser();
+	let byteOffset = 0;
+	const lines = raw.split("\n");
+	for (const [index, line] of lines.entries()) {
+		const lineEndOffset = byteOffset + Buffer.byteLength(line, "utf-8") + (index < lines.length - 1 ? 1 : 0);
+		parser.append(line, index, lineEndOffset);
+		byteOffset = lineEndOffset;
+	}
+	return parser.finish();
+}
+//#endregion
 //#region src/stores/ncp-agent-session-metadata.store.ts
 var NcpAgentSessionMetadataStore = class {
 	constructor(journalDir) {
@@ -7467,6 +7702,266 @@ var NcpAgentSessionMetadataStore = class {
 	};
 };
 //#endregion
+//#region src/utils/ncp-agent-session-message-projection.utils.ts
+const OFFSET_FIELD_WIDTH = 20;
+OFFSET_FIELD_WIDTH * 2 + 2;
+function serializeNcpAgentSessionMessage(message) {
+	return Buffer.from(`${JSON.stringify(message)}\n`, "utf-8");
+}
+function serializeNcpAgentSessionMessageLocation(location) {
+	const offset = String(location.offset).padStart(OFFSET_FIELD_WIDTH, "0");
+	const length = String(location.length).padStart(OFFSET_FIELD_WIDTH, "0");
+	if (offset.length !== OFFSET_FIELD_WIDTH || length.length !== OFFSET_FIELD_WIDTH) throw new Error("Session message projection exceeded its supported file size.");
+	return `${offset}:${length}\n`;
+}
+function parseNcpAgentSessionMessageLocation(value) {
+	const match = /^(\d{20}):(\d{20})\n$/.exec(value);
+	const offset = Number(match?.[1]);
+	const length = Number(match?.[2]);
+	if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 1) throw new Error("Session message projection contains an invalid offset record.");
+	return {
+		offset,
+		length
+	};
+}
+function encodeNcpAgentSessionMessageCursor(ordinal) {
+	return Buffer.from(`v1:${ordinal}`, "utf-8").toString("base64url");
+}
+function decodeNcpAgentSessionMessageCursor(cursor, maximumBoundary) {
+	let decoded = "";
+	try {
+		decoded = Buffer.from(cursor, "base64url").toString("utf-8");
+	} catch {
+		throw new SessionMessageCursorError();
+	}
+	const match = /^v1:([1-9]\d*)$/.exec(decoded);
+	const ordinal = Number(match?.[1]);
+	if (!Number.isSafeInteger(ordinal) || ordinal < 1 || ordinal > maximumBoundary) throw new SessionMessageCursorError();
+	return ordinal;
+}
+function deduplicateNcpAgentSessionTailMessages(messages) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		byId.delete(message.id);
+		byId.set(message.id, structuredClone(message));
+	}
+	return [...byId.values()];
+}
+//#endregion
+//#region src/stores/ncp-agent-session-message-projection.store.ts
+const PROJECTION_VERSION = 1;
+const PROJECTION_ROOT_DIRECTORY = ".message-projections";
+var NcpAgentSessionMessageProjectionStore = class {
+	constructor(journalDir, source) {
+		this.journalDir = journalDir;
+		this.source = source;
+	}
+	readMeta = async (sessionId) => {
+		try {
+			const parsed = JSON.parse(await readFile(this.metaPath(sessionId), "utf-8"));
+			if (parsed.version !== PROJECTION_VERSION || parsed.sessionId !== sessionId || !Number.isSafeInteger(parsed.total) || !Number.isSafeInteger(parsed.projectedJournalOffset) || !Number.isSafeInteger(parsed.dataBytes) || parsed.lastMessageId !== null && typeof parsed.lastMessageId !== "string" || parsed.contextWindow !== null && !isRecord$11(parsed.contextWindow)) return null;
+			const meta = parsed;
+			const [dataStat, offsetsStat] = await Promise.all([stat(this.dataPath(sessionId)), stat(this.offsetsPath(sessionId))]);
+			if (dataStat.size !== meta.dataBytes || offsetsStat.size !== meta.total * 42 || meta.total < 0 || meta.projectedJournalOffset < 0 || meta.dataBytes < 0) return null;
+			return structuredClone(meta);
+		} catch {
+			return null;
+		}
+	};
+	rebuild = async (params) => {
+		const { contextWindow, messages, projectedJournalOffset, sessionId } = params;
+		const projectionPath = this.projectionPath(sessionId);
+		const projectionRoot = dirname(projectionPath);
+		await mkdir(projectionRoot, { recursive: true });
+		const temporaryPath = await mkdtemp(join(projectionRoot, ".rebuild-"));
+		try {
+			const dataFile = await open(join(temporaryPath, "messages.jsonl"), "w");
+			let dataBytes = 0;
+			try {
+				const offsetsFile = await open(join(temporaryPath, "offsets.idx"), "w");
+				try {
+					for (const message of messages) {
+						const serialized = serializeNcpAgentSessionMessage(message);
+						await dataFile.write(serialized, 0, serialized.length, dataBytes);
+						await offsetsFile.write(serializeNcpAgentSessionMessageLocation({
+							offset: dataBytes,
+							length: serialized.length
+						}));
+						dataBytes += serialized.length;
+					}
+					await Promise.all([dataFile.sync(), offsetsFile.sync()]);
+				} finally {
+					await offsetsFile.close();
+				}
+			} finally {
+				await dataFile.close();
+			}
+			const meta = {
+				version: PROJECTION_VERSION,
+				sessionId,
+				total: messages.length,
+				lastMessageId: messages.at(-1)?.id ?? null,
+				projectedJournalOffset,
+				dataBytes,
+				contextWindow: contextWindow ? structuredClone(contextWindow) : null
+			};
+			await writeFile(join(temporaryPath, "meta.json"), `${JSON.stringify(meta)}\n`, "utf-8");
+			await rm(projectionPath, {
+				recursive: true,
+				force: true
+			});
+			await rename(temporaryPath, projectionPath);
+		} catch (error) {
+			await rm(temporaryPath, {
+				recursive: true,
+				force: true
+			});
+			throw error;
+		}
+	};
+	synchronize = async (params) => {
+		const { messages: sourceMessages, projectedJournalOffset, sessionId } = params;
+		const meta = await this.readMeta(sessionId);
+		if (!meta) return false;
+		const messages = deduplicateNcpAgentSessionTailMessages(sourceMessages);
+		const dataFile = await open(this.dataPath(sessionId), "r+");
+		const offsetsFile = await open(this.offsetsPath(sessionId), "r+");
+		try {
+			for (const message of messages) {
+				const serialized = serializeNcpAgentSessionMessage(message);
+				const location = {
+					offset: meta.dataBytes,
+					length: serialized.length
+				};
+				const serializedLocation = Buffer.from(serializeNcpAgentSessionMessageLocation(location), "utf-8");
+				await dataFile.write(serialized, 0, serialized.length, meta.dataBytes);
+				meta.dataBytes += serialized.length;
+				if (message.id === meta.lastMessageId && meta.total > 0) {
+					await offsetsFile.write(serializedLocation, 0, 42, (meta.total - 1) * 42);
+					continue;
+				}
+				await offsetsFile.write(serializedLocation, 0, 42, meta.total * 42);
+				meta.total += 1;
+				meta.lastMessageId = message.id;
+			}
+			await Promise.all([dataFile.sync(), offsetsFile.sync()]);
+		} finally {
+			await Promise.all([dataFile.close(), offsetsFile.close()]);
+		}
+		meta.projectedJournalOffset = projectedJournalOffset;
+		await this.writeMeta(meta);
+		return true;
+	};
+	updateContextWindow = async (sessionId, contextWindow) => {
+		const meta = await this.readMeta(sessionId);
+		if (!meta) return;
+		meta.contextWindow = contextWindow ? structuredClone(contextWindow) : null;
+		await this.writeMeta(meta);
+	};
+	listPage = async (params) => {
+		const { cursor, limit, sessionId } = params;
+		let meta = await this.readMeta(sessionId);
+		let tailMessages = null;
+		const journalStat = await stat(this.journalPath(sessionId));
+		if (meta && meta.projectedJournalOffset > journalStat.size) meta = null;
+		if (!meta) {
+			const loaded = await this.source?.loadSession(sessionId);
+			if (!loaded) return null;
+			tailMessages = await this.readJournalTailMessages(sessionId, loaded.projectedJournalOffset);
+			const tailMessageIds = new Set(tailMessages.map((message) => message.id));
+			await this.rebuild({
+				sessionId,
+				messages: loaded.record.messages.filter((message) => !tailMessageIds.has(message.id)),
+				projectedJournalOffset: loaded.projectedJournalOffset
+			});
+			meta = await this.readMeta(sessionId);
+		}
+		if (!meta) throw new Error(`Failed to build session message projection: ${sessionId}`);
+		return await this.readPage({
+			sessionId,
+			limit,
+			cursor,
+			tailMessages: tailMessages ?? await this.readJournalTailMessages(sessionId, meta.projectedJournalOffset)
+		});
+	};
+	readPage = async (params) => {
+		const { cursor, limit: requestedLimit, sessionId, tailMessages } = params;
+		const meta = await this.readMeta(sessionId);
+		if (!meta) return null;
+		const uniqueTailMessages = deduplicateNcpAgentSessionTailMessages(tailMessages ?? []);
+		const tailById = new Map(uniqueTailMessages.map((message) => [message.id, message]));
+		const additionalTailMessages = uniqueTailMessages.filter((message) => message.id !== meta.lastMessageId);
+		const limit = Number.isFinite(requestedLimit) ? Math.min(200, Math.max(1, Math.trunc(requestedLimit))) : 80;
+		const boundary = cursor ? decodeNcpAgentSessionMessageCursor(cursor, meta.total + 1) : meta.total + 1;
+		const includeTail = !cursor;
+		const stableLimit = includeTail ? Math.max(0, limit - additionalTailMessages.length) : limit;
+		const endOrdinal = Math.min(meta.total, boundary - 1);
+		const startOrdinal = stableLimit > 0 ? Math.max(1, endOrdinal - stableLimit + 1) : endOrdinal + 1;
+		const stableMessages = startOrdinal <= endOrdinal ? await this.readMessages(sessionId, startOrdinal, endOrdinal) : [];
+		const messages = stableMessages.map((message) => tailById.get(message.id) ?? message);
+		if (includeTail) messages.push(...additionalTailMessages);
+		const cursorOrdinal = stableMessages.length > 0 ? startOrdinal : meta.total + 1;
+		return {
+			messages,
+			total: meta.total + additionalTailMessages.length,
+			pageInfo: {
+				startCursor: messages.length > 0 ? encodeNcpAgentSessionMessageCursor(cursorOrdinal) : null,
+				hasPreviousPage: cursorOrdinal > 1
+			},
+			contextWindow: meta.contextWindow ? structuredClone(meta.contextWindow) : null
+		};
+	};
+	readJournalTailMessages = async (sessionId, offset) => {
+		const file = await open(this.journalPath(sessionId), "r");
+		try {
+			const fileStat = await file.stat();
+			if (offset < 0 || offset > fileStat.size || offset === fileStat.size) return [];
+			const buffer = Buffer.alloc(fileStat.size - offset);
+			const result = await file.read(buffer, 0, buffer.length, offset);
+			return await replayNcpAgentSessionEvents(parseNcpAgentSessionJournal(buffer.subarray(0, result.bytesRead).toString("utf-8")).events);
+		} finally {
+			await file.close();
+		}
+	};
+	delete = async (sessionId) => {
+		await rm(this.projectionPath(sessionId), {
+			recursive: true,
+			force: true
+		});
+	};
+	readMessages = async (sessionId, startOrdinal, endOrdinal) => {
+		const count = endOrdinal - startOrdinal + 1;
+		const indexBuffer = Buffer.alloc(count * 42);
+		const offsetsFile = await open(this.offsetsPath(sessionId), "r");
+		const dataFile = await open(this.dataPath(sessionId), "r");
+		try {
+			if ((await offsetsFile.read(indexBuffer, 0, indexBuffer.length, (startOrdinal - 1) * 42)).bytesRead !== indexBuffer.length) throw new Error("Session message projection ended before the requested page.");
+			const messages = [];
+			for (let index = 0; index < count; index += 1) {
+				const recordStart = index * 42;
+				const location = parseNcpAgentSessionMessageLocation(indexBuffer.subarray(recordStart, recordStart + 42).toString("utf-8"));
+				const messageBuffer = Buffer.alloc(location.length);
+				if ((await dataFile.read(messageBuffer, 0, location.length, location.offset)).bytesRead !== location.length) throw new Error("Session message projection contains a truncated message.");
+				messages.push(JSON.parse(messageBuffer.toString("utf-8")));
+			}
+			return messages;
+		} finally {
+			await Promise.all([offsetsFile.close(), dataFile.close()]);
+		}
+	};
+	writeMeta = async (meta) => {
+		const path = this.metaPath(meta.sessionId);
+		const temporaryPath = `${path}.${process.pid}.tmp`;
+		await writeFile(temporaryPath, `${JSON.stringify(meta)}\n`, "utf-8");
+		await rename(temporaryPath, path);
+	};
+	projectionPath = (sessionId) => join(this.journalDir, PROJECTION_ROOT_DIRECTORY, safeNcpSessionFilename(sessionId));
+	journalPath = (sessionId) => join(this.journalDir, `${safeNcpSessionFilename(sessionId)}.jsonl`);
+	metaPath = (sessionId) => join(this.projectionPath(sessionId), "meta.json");
+	dataPath = (sessionId) => join(this.projectionPath(sessionId), "messages.jsonl");
+	offsetsPath = (sessionId) => join(this.projectionPath(sessionId), "offsets.idx");
+};
+//#endregion
 //#region src/stores/ncp-agent-session-summary-index.store.ts
 function stripSummaryMetadata(summary) {
 	const { metadata: _metadata, ...nextSummary } = summary;
@@ -7543,31 +8038,21 @@ var NcpAgentSessionSummaryIndexStore = class {
 };
 //#endregion
 //#region src/stores/ncp-agent-session-journal.store.ts
-function serializeJournalEntry(entry) {
-	const serialized = JSON.stringify(entry);
-	if (!serialized) throw new Error("ncp agent session journal entry serialization produced empty output");
-	if (!isRecord$11(JSON.parse(serialized))) throw new Error("ncp agent session journal entry serialization produced a non-object entry");
-	return serialized;
-}
-function attachJournalTimestamp(event, timestamp) {
-	if (!("payload" in event) || !isRecord$11(event.payload)) return event;
-	return {
-		...event,
-		payload: {
-			...event.payload,
-			timestamp
-		}
-	};
-}
 var NcpAgentSessionJournalStore = class {
 	sessions = /* @__PURE__ */ new Map();
 	nextSeqBySession = /* @__PURE__ */ new Map();
 	writeChains = /* @__PURE__ */ new Map();
 	metadataStore;
+	messageProjectionStore;
 	summaryIndexStore;
 	constructor(journalDir) {
 		this.journalDir = journalDir;
 		this.metadataStore = new NcpAgentSessionMetadataStore(journalDir);
+		this.messageProjectionStore = new NcpAgentSessionMessageProjectionStore(journalDir, { loadSession: async (sessionId) => {
+			const loaded = this.sessions.get(sessionId) ?? await this.loadSession(sessionId);
+			if (loaded) this.sessions.set(sessionId, loaded);
+			return loaded;
+		} });
 		this.summaryIndexStore = new NcpAgentSessionSummaryIndexStore(journalDir, async (sessionId) => this.loadSession(sessionId));
 	}
 	appendSessionEvent = async (params) => {
@@ -7598,6 +8083,20 @@ var NcpAgentSessionJournalStore = class {
 		const session = await this.getSession(sessionId);
 		return session ? session.messages.map((message) => structuredClone(message)) : [];
 	};
+	listSessionMessagePage = async (params) => {
+		const sessionId = normalizeNcpSessionId(params.sessionId);
+		if (!sessionId) return null;
+		return await this.messageProjectionStore.listPage({
+			sessionId,
+			limit: params.limit,
+			cursor: params.cursor
+		});
+	};
+	updateSessionMessageProjectionContextWindow = async (sessionId, contextWindow) => {
+		const normalizedSessionId = normalizeNcpSessionId(sessionId);
+		if (!normalizedSessionId) return;
+		await this.messageProjectionStore.updateContextWindow(normalizedSessionId, contextWindow);
+	};
 	setSessionMetadata = async (params) => {
 		const sessionId = normalizeNcpSessionId(params.sessionId);
 		if (!sessionId) return false;
@@ -7629,7 +8128,8 @@ var NcpAgentSessionJournalStore = class {
 		await this.metadataStore.write(nextRecord);
 		this.sessions.set(sessionId, {
 			record: nextRecord,
-			nextSeq: loaded.nextSeq
+			nextSeq: loaded.nextSeq,
+			projectedJournalOffset: loaded.projectedJournalOffset
 		});
 		this.nextSeqBySession.set(sessionId, loaded.nextSeq);
 		await this.summaryIndexStore.upsert(createNcpAgentSessionSummary(nextRecord));
@@ -7668,13 +8168,20 @@ var NcpAgentSessionJournalStore = class {
 				}
 			}
 		}));
-		await writeFile(this.sessionPath(sessionId), entries.length > 0 ? `${entries.map(serializeJournalEntry).join("\n")}\n` : "", "utf-8");
+		await writeFile(this.sessionPath(sessionId), entries.length > 0 ? `${entries.map(serializeNcpAgentSessionJournalEntry).join("\n")}\n` : "", "utf-8");
 		const nextSeq = nextRecord.messages.length + 1;
+		const journalStat = await stat(this.sessionPath(sessionId));
 		this.sessions.set(sessionId, {
 			record: nextRecord,
-			nextSeq
+			nextSeq,
+			projectedJournalOffset: journalStat.size
 		});
 		this.nextSeqBySession.set(sessionId, nextSeq);
+		await this.messageProjectionStore.rebuild({
+			sessionId,
+			messages: nextRecord.messages,
+			projectedJournalOffset: journalStat.size
+		});
 		await this.summaryIndexStore.upsert(createNcpAgentSessionSummary(nextRecord));
 	};
 	deleteSession = async (sessionId) => {
@@ -7687,6 +8194,7 @@ var NcpAgentSessionJournalStore = class {
 			await unlink(this.sessionPath(normalizedSessionId));
 		} catch {}
 		await this.metadataStore.delete(normalizedSessionId);
+		await this.messageProjectionStore.delete(normalizedSessionId);
 		await this.summaryIndexStore.remove(normalizedSessionId);
 		return existing;
 	};
@@ -7712,6 +8220,18 @@ var NcpAgentSessionJournalStore = class {
 		await this.appendJournalEntry(path, entry);
 		this.nextSeqBySession.set(sessionId, nextSeq + 1);
 		this.sessions.delete(sessionId);
+		if (isNcpAgentSessionMessageProjectionBoundaryEvent(event)) {
+			const journalStat = await stat(path);
+			const projectionMeta = await this.messageProjectionStore.readMeta(sessionId);
+			if (projectionMeta) {
+				const projectionTail = await this.messageProjectionStore.readJournalTailMessages(sessionId, projectionMeta.projectedJournalOffset);
+				await this.messageProjectionStore.synchronize({
+					sessionId,
+					messages: projectionTail,
+					projectedJournalOffset: journalStat.size
+				});
+			}
+		}
 		await this.summaryIndexStore.upsertForEvent({
 			sessionId,
 			event,
@@ -7740,9 +8260,9 @@ var NcpAgentSessionJournalStore = class {
 		} catch {
 			return null;
 		}
-		const parsedJournal = this.parseSessionJournal(raw);
+		const parsedJournal = parseNcpAgentSessionJournal(raw);
 		const { agentId, createdAt, updatedAt, metadata } = await this.metadataStore.read(sessionId, parsedJournal);
-		const { events, nextSeq } = parsedJournal;
+		const { events, nextSeq, projectedJournalOffset } = parsedJournal;
 		const messages = await replayNcpAgentSessionEvents(events);
 		const record = {
 			sessionId,
@@ -7755,53 +8275,12 @@ var NcpAgentSessionJournalStore = class {
 		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 [index, line] of raw.split("\n").entries()) {
-			if (!line.trim()) continue;
-			let parsed;
-			try {
-				parsed = JSON.parse(line);
-			} catch (error) {
-				console.warn(`[ncp-agent-session-journal] skipped corrupted journal line ${index + 1}: ${error instanceof Error ? error.message : String(error)}`);
-				continue;
-			}
-			if (!isRecord$11(parsed)) continue;
-			if (parsed._type === "metadata") {
-				metadata = isRecord$11(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$11(parsed.event)) {
-				const seq = Number(parsed.seq);
-				nextSeq = Math.max(nextSeq, Number.isFinite(seq) ? Math.trunc(seq) + 1 : nextSeq);
-				const eventTimestamp = toIsoString(parsed.timestamp, updatedAt);
-				updatedAt = eventTimestamp;
-				const event = structuredClone(parsed.event);
-				events.push(attachJournalTimestamp(event, eventTimestamp));
-			}
-		}
-		return {
-			metadata,
-			...agentId ? { agentId } : {},
-			createdAt,
-			updatedAt,
 			nextSeq,
-			events
+			projectedJournalOffset
 		};
 	};
 	appendJournalEntry = async (path, entry) => {
-		await appendFile(path, `${serializeJournalEntry(entry)}\n`, "utf-8");
+		await appendFile(path, `${serializeNcpAgentSessionJournalEntry(entry)}\n`, "utf-8");
 	};
 	ensureJournalDir = async () => {
 		await mkdir(this.journalDir, { recursive: true });
@@ -8920,9 +9399,10 @@ var NcpAgentRuntimeWrapper = class {
 		this.params = params;
 	}
 	run = async function* (spec, options) {
-		const { sessionRun, tools } = options;
+		const { session, sessionRun, signal, tools } = options;
 		this.currentTools = tools.map(this.toOpenAiTool);
 		const messages = sessionRun.inbox.drain();
+		let executionMetadataSeen = false;
 		try {
 			for (const event of this.toMessageSentEvents(messages, spec, sessionRun.sessionId)) yield await this.applyEvent(sessionRun, event);
 			const input = {
@@ -8930,10 +9410,18 @@ var NcpAgentRuntimeWrapper = class {
 				runId: spec.runId,
 				messages,
 				correlationId: spec.correlationId,
-				metadata: this.buildMetadata(options.session, spec),
-				executionContext: { cwd: options.session.workingDir }
+				metadata: this.buildMetadata(session, spec),
+				executionContext: { cwd: session.workingDir }
 			};
-			for await (const event of this.getRuntime().run(input, { signal: options.signal })) yield await this.applyEvent(sessionRun, event);
+			for await (const event of this.getRuntime().run(input, { signal })) {
+				if (event.type === NcpEventType.RunMetadata && readNcpAiExecutionMetadata(event.payload.metadata)) executionMetadataSeen = true;
+				const terminalOutcome = this.readTerminalOutcome(event);
+				if (terminalOutcome && !executionMetadataSeen) {
+					yield await this.applyEvent(sessionRun, this.createExecutionMetadataEvent(spec, session, event, terminalOutcome));
+					executionMetadataSeen = true;
+				}
+				yield await this.applyEvent(sessionRun, event);
+			}
 		} finally {
 			this.currentTools = [];
 		}
@@ -8971,6 +9459,28 @@ var NcpAgentRuntimeWrapper = class {
 		preferred_model: spec.model,
 		thinkingEffort: spec.thinkingEffort
 	});
+	readTerminalOutcome = (event) => {
+		if (event.type === NcpEventType.RunFinished) return "completed";
+		if (event.type === NcpEventType.RunError) return "failed";
+		if (event.type === NcpEventType.MessageAbort) return "aborted";
+		return null;
+	};
+	createExecutionMetadataEvent = (spec, session, terminalEvent, outcome) => ({
+		occurredAt: terminalEvent.occurredAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		type: NcpEventType.RunMetadata,
+		payload: {
+			runId: spec.runId,
+			sessionId: session.sessionId,
+			correlationId: spec.correlationId,
+			metadata: { [NCP_AI_EXECUTION_METADATA_KEY]: createUnavailableNcpAiExecutionMetadata({
+				runId: spec.runId,
+				runtimeId: spec.runtimeId,
+				model: spec.model,
+				requestedModel: spec.requestedModel,
+				outcome
+			}) }
+		}
+	});
 	toOpenAiTool = (tool) => buildOpenAiFunctionTool({
 		name: tool.name,
 		description: tool.description,
@@ -9489,17 +9999,39 @@ var SkillsContextProvider = class {
 };
 //#endregion
 //#region src/contributions/context-provider/providers/tooling-context.provider.ts
+function readSearchApiKey(searchConfig, provider) {
+	if (provider === "bocha") return searchConfig?.providers?.bocha?.apiKey?.trim() ?? "";
+	if (provider === "tavily") return searchConfig?.providers?.tavily?.apiKey?.trim() ?? "";
+	return searchConfig?.providers?.brave?.apiKey?.trim() ?? "";
+}
+function renderWebSearchReadiness(params) {
+	const { searchConfig, toolNames } = params;
+	if (!toolNames.includes("web_search")) return "web_search is unavailable in this turn.";
+	const provider = searchConfig?.provider ?? "bocha";
+	if (!(searchConfig?.enabledProviders ?? ["bocha"]).includes(provider)) return `web_search is not ready: provider ${provider} is not enabled.`;
+	if (!readSearchApiKey(searchConfig, provider)) return `web_search is not ready: provider ${provider} has no API key configured.`;
+	return `web_search is ready with provider ${provider}.`;
+}
 var ToolingContextProvider = class {
 	constructor(context) {
 		this.context = context;
 	}
 	provide = async (request) => {
-		const { toolCatalog } = await this.context.resolve(request);
+		const { runContext, toolCatalog } = await this.context.resolve(request);
 		return [[
 			"## Tooling",
 			"Tool availability (filtered by policy):",
 			"Tool names are case-sensitive. Call tools exactly as listed.",
 			...toolCatalog.length > 0 ? toolCatalog.map((tool) => `- ${tool.name}: ${tool.description ?? "No description available"}`) : ["- No tools available for this turn."],
+			"Web access policy:",
+			`- ${renderWebSearchReadiness({
+				searchConfig: runContext.profile.searchConfig,
+				toolNames: toolCatalog.map((tool) => tool.name)
+			})}`,
+			"- web_search and Agent Browser are distinct capabilities: web_search is for open-ended source discovery; Agent Browser operates real browser pages.",
+			"- In this policy, Agent Browser means the external agent-browser CLI documented by the builtin skill. web_fetch, Chrome/Edge DevTools MCP, and Browser Connector are separate capabilities and must not be called Agent Browser.",
+			"- Prefer a ready web_search for open-ended discovery. If it is unavailable, not configured, or returns an error, and browser navigation can still make progress, briefly tell the user you are switching to browser automation, then read and follow the builtin agent-browser skill.",
+			"- Do not describe Agent Browser output as web_search output, and do not silently install its external CLI.",
 			"TOOLS.md does not control tool availability; it is user guidance for how to use external tools.",
 			"For long waits, avoid rapid poll loops: use exec with enough yieldMs.",
 			"For relative time/date scheduling requests (for example 'in 5 minutes' / '1分钟后'), first check the current local time with an available tool such as exec/date, then convert it to an absolute ISO time with timezone. Do not guess.",
@@ -11857,6 +12389,6 @@ function resolveLegacyEventType(message) {
 	return `message.${role || "other"}`;
 }
 //#endregion
-export { AUTOMATIC_UPDATE_CHECK_INTERVAL_MS, AccessManager, AgentManager, AgentRunClient, AutomationManager, BuiltinNarpRuntimeProviderService, CONTEXT_COMPACTION_PROJECTION_KIND, CONTEXT_COMPACTION_PROJECTION_METADATA_KEY, CONTEXT_COMPACTION_TIMELINE_KIND, ChannelManager, CommandRegistry, ConfigManager, ContextCompactionPreflightService, ContextWindowPreviewManager, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DEFAULT_SERVICE_ACTION_RISK, ExtensionManager, GatewayInboundProcessor, LlmProviderManager, LlmUsageManager, LlmUsageStore, McpManager, McpServiceAppRuntimeService, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NEXTCLAW_TIMELINE_KIND_METADATA_KEY, NcpAgentSessionJournalStore, NextclawKernel, PANEL_APP_AGENT_CAPABILITIES, PROJECT_TEMPLATE_IDS, PanelAppAssetTokenService, PanelAppError, PanelAppManager, PreferenceError, PreferenceManager, ProjectError, ProjectManager, ProviderManagerNcpLLMApi, SERVICE_APP_MANIFEST_FILE_NAME, ServiceAppError, ServiceAppManager, SessionManager, SessionRequestManager, SessionSettingsError, SkillManager, UpdateManifestReader, buildAgentRunSendPayload, buildContextCompactionModelInput, buildContextCompactionTimelineNcpMessage, buildLlmUsageSummary, buildLocalizedTextMap, buildNextclawNcpRunContext, buildServiceActionId, createAgentRuntimeSessionRequestDispatcher, createAssetTools, createContextCompactionMessageId, createContextWindowSignature, createLlmUsageRecord, describeAgentRuntimeSessionTypes, dispatchAgentRuntimeSessionRequest, dispatchChannelReplyRoute, dispatchPromptOverNcp, getAutomaticUpdateCheckDelay, getServiceActionName, getServiceAppManifestPath, getUnsignedUpdateManifest, hasLlmUsageTelemetry, isContextCompactionProjectionMessage, isContextCompactionTimelineMessage, isContextWindowSnapshot, isPanelAppAgentCapability, isPanelAppError, isPreferenceError, isProjectError, isReplyCapableChannel, isServiceAppError, isSessionSettingsError, listExtensionChannelIds, listServiceAppManifestActions, mergeServiceAppRuntimeActions, normalizeAgentRuntimeSessionTypeIcon, normalizeLlmUsageModel, normalizeOptionalString, parseServiceAppManifest, parseSkillFrontmatter, readContextWindowEventSessionId, readLatestContextCompactionCheckpoint, readLearningLoopRuntimeConfig, readMetadataModel, readMetadataThinking, readServiceAppManifest, resolveAgentRuntimeEntries, resolveAutomaticUpdateCheckIntervalMs, resolveChannelReplyRoute, resolveEffectiveModel, resolveLegacyEventType, resolveSessionChannelContext, runGatewayInboundLoop, sanitizeLlmUsage, serializeUnsignedUpdateManifest, shouldRefreshContextWindowDuringStream, shouldRefreshContextWindowImmediately, stripSkillFrontmatter, syncSessionThinkingPreference, toNcpMessages, waitForAgentRuntimeSessionReply };
+export { AUTOMATIC_UPDATE_CHECK_INTERVAL_MS, AccessManager, AgentManager, AgentRunClient, AutomationManager, BuiltinNarpRuntimeProviderService, CONTEXT_COMPACTION_PROJECTION_KIND, CONTEXT_COMPACTION_PROJECTION_METADATA_KEY, CONTEXT_COMPACTION_TIMELINE_KIND, ChannelManager, CommandRegistry, ConfigManager, ContextCompactionPreflightService, ContextWindowPreviewManager, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DEFAULT_SERVICE_ACTION_RISK, ExtensionManager, GatewayInboundProcessor, LlmProviderManager, LlmUsageManager, LlmUsageStore, McpManager, McpServiceAppRuntimeService, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NEXTCLAW_TIMELINE_KIND_METADATA_KEY, NcpAgentSessionJournalStore, NextclawKernel, PANEL_APP_AGENT_CAPABILITIES, PROJECT_TEMPLATE_IDS, PanelAppAssetTokenService, PanelAppError, PanelAppManager, PreferenceError, PreferenceManager, ProjectError, ProjectManager, ProviderManagerNcpLLMApi, SERVICE_APP_MANIFEST_FILE_NAME, ServiceAppError, ServiceAppManager, SessionManager, SessionMessageCursorError, SessionRequestManager, SessionSettingsError, SkillManager, UpdateManifestReader, buildAgentRunSendPayload, buildContextCompactionModelInput, buildContextCompactionTimelineNcpMessage, buildLlmUsageSummary, buildLocalizedTextMap, buildNextclawNcpRunContext, buildServiceActionId, createAgentRuntimeSessionRequestDispatcher, createAssetTools, createContextCompactionMessageId, createContextWindowSignature, createLlmUsageRecord, describeAgentRuntimeSessionTypes, dispatchAgentRuntimeSessionRequest, dispatchChannelReplyRoute, dispatchPromptOverNcp, getAutomaticUpdateCheckDelay, getServiceActionName, getServiceAppManifestPath, getUnsignedUpdateManifest, hasLlmUsageTelemetry, isContextCompactionProjectionMessage, isContextCompactionTimelineMessage, isContextWindowSnapshot, isPanelAppAgentCapability, isPanelAppError, isPreferenceError, isProjectError, isReplyCapableChannel, isServiceAppError, isSessionMessageCursorError, isSessionSettingsError, listExtensionChannelIds, listServiceAppManifestActions, mergeServiceAppRuntimeActions, normalizeAgentRuntimeSessionTypeIcon, normalizeLlmUsageModel, normalizeOptionalString, parseServiceAppManifest, parseSkillFrontmatter, readContextWindowEventSessionId, readLatestContextCompactionCheckpoint, readLearningLoopRuntimeConfig, readMetadataModel, readMetadataThinking, readServiceAppManifest, resolveAgentRuntimeEntries, resolveAutomaticUpdateCheckIntervalMs, resolveChannelReplyRoute, resolveEffectiveModel, resolveLegacyEventType, resolveSessionChannelContext, runGatewayInboundLoop, sanitizeLlmUsage, serializeUnsignedUpdateManifest, shouldRefreshContextWindowDuringStream, shouldRefreshContextWindowImmediately, stripSkillFrontmatter, syncSessionThinkingPreference, toNcpMessages, waitForAgentRuntimeSessionReply };
 
 //# sourceMappingURL=index.js.map