nextclaw 0.18.10 → 0.18.12-beta.0

package/dist/cli/app/index.js

@@ -1,20 +1,24 @@
 #!/usr/bin/env node
+import { _ as waitForExit, a as findExecutableOnPath, c as isProcessRunning, d as prompt, f as resolvePublicIp, g as resolveUiStaticDir, h as resolveUiConfig, i as NpmRuntimeBundleLayoutStore, l as openBrowser, m as resolveUiApiBase, n as NpmRuntimeBundleService, o as getPackageVersion$1, p as resolveServiceLogPath, r as compareNpmRuntimeVersions, s as isLoopbackHost, t as NpmRuntimeUpdateStateStore, u as printAgentResponse } from "../../npm-runtime-update-state.store-DaF0iDY9.js";
 import { createRequire } from "node:module";
 import * as NextclawCore from "@nextclaw/core";
-import { APP_NAME, APP_TAGLINE, AgentRouteResolver, BUILTIN_MAIN_AGENT_ID, ChannelManager, CommandRegistry, ConfigSchema, ContextBuilder, CronService, CronTool, DEFAULT_WORKSPACE_DIR, DEFAULT_WORKSPACE_PATH, DisposableStore, EditFileTool, ExecTool, ExtensionToolAdapter, FileLogSink, GatewayTool, InputBudgetPruner, LLMProvider, ListDirTool, MemoryGetTool, MemorySearchTool, MessageBus, MessageTool, ProviderManager, ReadFileTool, RequestedSkillsMetadataReader, SessionManager, SessionsHistoryTool, SessionsListTool, SkillsLoader, Tool, ToolRegistry, WebFetchTool, WebSearchTool, WriteFileTool, buildConfigSchema, buildMinimalSystemExecutionPrompt, buildReloadPlan, buildToolCatalogEntries, createAgentProfile, createAssistantStreamDeltaControlMessage, createAssistantStreamResetControlMessage, createExternalCommandEnv, createGlobalTypedEventBus, createTypedEventKey, createTypingStopControlMessage, diffConfigPaths, expandHome, findEffectiveAgentProfile, getAppLogger, getConfigPath, getDataDir, getDataPath, getLoggingRuntime, getLogsPath, getPackageVersion, getWorkspacePath, hasSecretRef, loadConfig, normalizeInlineSecretRefs, parseAgentScopedSessionKey, parseThinkingLevel, readSessionProjectRoot, redactConfigObject, removeAgentProfile, resolveAppLogPath, resolveConfigSecrets, resolveDefaultAgentProfileId, resolveEffectiveAgentProfiles, resolveLocalUiBaseUrl, resolveProviderRuntime, resolveSessionWorkspacePath, resolveThinkingLevel, saveConfig, toDisposable, updateAgentProfile } from "@nextclaw/core";
+import { APP_NAME, APP_TAGLINE, AgentRouteResolver, BUILTIN_MAIN_AGENT_ID, ChannelManager, CommandRegistry, ConfigSchema, ContextBuilder, CronService, CronTool, DEFAULT_WORKSPACE_DIR, DEFAULT_WORKSPACE_PATH, DisposableStore, EditFileTool, ExecTool, ExtensionToolAdapter, FileLogSink, GatewayTool, InputBudgetPruner, LLMProvider, ListDirTool, MemoryGetTool, MemorySearchTool, MessageBus, MessageTool, ProviderManager, ReadFileTool, RequestedSkillsMetadataReader, SessionManager, SessionsHistoryTool, SessionsListTool, SkillsLoader, Tool, ToolRegistry, WebFetchTool, WebSearchTool, WriteFileTool, buildConfigSchema, buildMinimalSystemExecutionPrompt, buildReloadPlan, buildToolCatalogEntries, createAgentProfile, createAssistantStreamDeltaControlMessage, createAssistantStreamResetControlMessage, createGlobalTypedEventBus, createTypedEventKey, createTypingStopControlMessage, diffConfigPaths, expandHome, findEffectiveAgentProfile, getAppLogger, getConfigPath, getDataDir, getDataPath, getLoggingRuntime, getWorkspacePath, hasSecretRef, loadConfig, normalizeInlineSecretRefs, parseAgentScopedSessionKey, parseThinkingLevel, readSessionProjectRoot, redactConfigObject, removeAgentProfile, resolveAppLogPath, resolveConfigSecrets, resolveDefaultAgentProfileId, resolveEffectiveAgentProfiles, resolveLocalUiBaseUrl, resolveProviderRuntime, resolveSessionWorkspacePath, resolveThinkingLevel, saveConfig, toDisposable, updateAgentProfile } from "@nextclaw/core";
 import { Command } from "commander";
 import fs, { appendFileSync, closeSync, constants, cpSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
-import path, { basename, delimiter, dirname, extname, isAbsolute, join, relative, resolve, win32 } from "node:path";
+import path, { basename, delimiter, dirname, extname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
 import { homedir, hostname, platform } from "node:os";
 import { ensureUiBridgeSecret, startUiServer } from "@nextclaw/server";
 import { addPluginLoadPath, buildPluginStatusReport, disablePluginInConfig, discoverPluginStatusReport, enablePluginInConfig, getPackageManifestExtensions, getPluginChannelBindings, getPluginUiMetadataFromRegistry, installPluginFromNpmSpec, installPluginFromPath, loadOpenClawPlugins, loadOpenClawPluginsProgressively, loadPluginManifest, mergePluginConfigView, recordPluginInstall, resolvePluginChannelMessageToolHints, resolveUninstallDirectoryTargets, setPluginRuntimeBridge, startPluginChannelGateways, stopPluginChannelGateways, toPluginConfigView, toPluginConfigView as toPluginConfigView$1, uninstallPlugin } from "@nextclaw/openclaw-compat";
 import { fileURLToPath } from "node:url";
 import { spawn, spawnSync } from "node:child_process";
-import { createServer, isIP } from "node:net";
+import { createServer } from "node:net";
+import { access, readFile, rm } from "node:fs/promises";
+import { createHash, createPublicKey, randomUUID, verify } from "node:crypto";
+import JSZip from "jszip";
+import { UpdateManifestReader, serializeUnsignedUpdateManifest } from "@nextclaw/kernel/update-contract";
 import { BUILTIN_CHANNEL_PLUGIN_IDS, builtinProviderIds, listBuiltinProviders } from "@nextclaw/runtime";
 import { createInterface } from "node:readline";
 import { McpDoctorFacade, McpMutationService, McpRegistryService, McpServerLifecycleManager } from "@nextclaw/mcp";
-import { access, readFile } from "node:fs/promises";
 import { HttpRuntimeConfigResolver, HttpRuntimeNcpAgentRuntime } from "@nextclaw/nextclaw-ncp-runtime-http-client";
 import { StdioRuntimeConfigResolver, StdioRuntimeNcpAgentRuntime, probeStdioRuntime } from "@nextclaw/nextclaw-ncp-runtime-stdio-client";
 import { buildHermesAcpBridgeLaunchEnv, isHermesAcpRuntimeConfig } from "@nextclaw/nextclaw-hermes-acp-bridge";
@@ -22,7 +26,6 @@ import { DefaultNcpAgentRuntime, LocalAssetStore, buildAssetContentPath, buildNc
 import { McpNcpToolRegistryAdapter } from "@nextclaw/ncp-mcp";
 import { NCP_INTERNAL_VISIBILITY_METADATA_KEY, NcpEventType, readAssistantReasoningNormalizationMode, readAssistantReasoningNormalizationModeFromMetadata, sanitizeAssistantReplyTags, writeAssistantReasoningNormalizationModeToMetadata } from "@nextclaw/ncp";
 import { DefaultNcpAgentBackend, createAgentClientFromServer } from "@nextclaw/ncp-toolkit";
-import { createHash, randomUUID } from "node:crypto";
 import { setImmediate as setImmediate$1, setTimeout as setTimeout$1 } from "node:timers/promises";
 import { request } from "node:http";
 import { request as request$1 } from "node:https";
@@ -165,7 +168,7 @@ function maskToken(value) {
 	if (value.length <= 12) return "<redacted>";
 	return `${value.slice(0, 6)}...${value.slice(-4)}`;
 }
-function normalizeOptionalString$9(value) {
+function normalizeOptionalString$10(value) {
 	if (typeof value !== "string") return;
 	const trimmed = value.trim();
 	return trimmed.length > 0 ? trimmed : void 0;
@@ -263,8 +266,8 @@ var RemotePlatformClient = class {
 		if (tokenState.reason === "missing") throw new Error("NextClaw platform token is missing. Run \"nextclaw login\" first.");
 		if (tokenState.reason === "expired") throw new Error("NextClaw platform token expired. Run \"nextclaw login\" or browser sign-in again.");
 		if (tokenState.reason === "malformed") throw new Error("NextClaw platform token is invalid. Run \"nextclaw login\" again.");
-		const configuredApiBase = normalizeOptionalString$9(config.remote.platformApiBase) ?? (typeof nextclawProvider?.apiBase === "string" ? nextclawProvider.apiBase.trim() : "");
-		const rawApiBase = normalizeOptionalString$9(opts.apiBase) ?? configuredApiBase;
+		const configuredApiBase = normalizeOptionalString$10(config.remote.platformApiBase) ?? (typeof nextclawProvider?.apiBase === "string" ? nextclawProvider.apiBase.trim() : "");
+		const rawApiBase = normalizeOptionalString$10(opts.apiBase) ?? configuredApiBase;
 		if (!rawApiBase) throw new Error("Platform API base is missing. Pass --api-base, run nextclaw login, or set remote.platformApiBase.");
 		return {
 			platformBase: this.deps.resolvePlatformBase(rawApiBase),
@@ -273,14 +276,14 @@ var RemotePlatformClient = class {
 		};
 	}
 	resolveLocalOrigin(config, opts) {
-		const explicitOrigin = normalizeOptionalString$9(opts.localOrigin);
+		const explicitOrigin = normalizeOptionalString$10(opts.localOrigin);
 		if (explicitOrigin) return explicitOrigin.replace(/\/$/, "");
 		const state = this.deps.readManagedServiceState?.();
 		if (state && this.deps.isProcessRunning?.(state.pid) && Number.isFinite(state.uiPort)) return `http://127.0.0.1:${state.uiPort}`;
 		return `http://127.0.0.1:${typeof config.ui?.port === "number" && Number.isFinite(config.ui.port) ? config.ui.port : 55667}`;
 	}
 	resolveDisplayName(config, opts) {
-		return normalizeOptionalString$9(opts.name) ?? normalizeOptionalString$9(config.remote.deviceName) ?? hostname();
+		return normalizeOptionalString$10(opts.name) ?? normalizeOptionalString$10(config.remote.deviceName) ?? hostname();
 	}
 };
 //#endregion
@@ -4490,7 +4493,7 @@ var RemoteConnector = class {
 };
 //#endregion
 //#region ../nextclaw-remote/src/remote-status-store.ts
-function normalizeOptionalString$8(value) {
+function normalizeOptionalString$9(value) {
 	if (typeof value !== "string") return;
 	const trimmed = value.trim();
 	return trimmed.length > 0 ? trimmed : void 0;
@@ -4501,8 +4504,8 @@ function buildConfiguredRemoteState(config) {
 		enabled: Boolean(remote.enabled),
 		mode: "service",
 		state: remote.enabled ? "disconnected" : "disabled",
-		...normalizeOptionalString$8(remote.deviceName) ? { deviceName: normalizeOptionalString$8(remote.deviceName) } : {},
-		...normalizeOptionalString$8(remote.platformApiBase) ? { platformBase: normalizeOptionalString$8(remote.platformApiBase) } : {},
+		...normalizeOptionalString$9(remote.deviceName) ? { deviceName: normalizeOptionalString$9(remote.deviceName) } : {},
+		...normalizeOptionalString$9(remote.platformApiBase) ? { platformBase: normalizeOptionalString$9(remote.platformApiBase) } : {},
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
 }
@@ -4515,7 +4518,7 @@ function resolveRemoteStatusSnapshot(params) {
 		configuredEnabled: true,
 		runtime: {
 			...buildConfiguredRemoteState(params.config),
-			deviceName: normalizeOptionalString$8(params.config.remote.deviceName) ?? normalizeOptionalString$8(params.fallbackDeviceName) ?? hostname()
+			deviceName: normalizeOptionalString$9(params.config.remote.deviceName) ?? normalizeOptionalString$9(params.fallbackDeviceName) ?? hostname()
 		}
 	};
 	return {
@@ -5119,331 +5122,471 @@ async function measureStartupAsync(step, fn, fields) {
 	}
 }
 //#endregion
-//#region src/cli/shared/utils/self-update-report.utils.ts
-function reportSelfUpdateResult(params) {
-	const { appName, currentVersion, result, readInstalledVersion } = params;
-	const printSteps = () => {
-		for (const step of result.steps) {
-			console.log(`- ${step.cmd} ${step.args.join(" ")} (code ${step.code ?? "?"})`);
-			if (step.stderr) console.log(`  stderr: ${step.stderr}`);
-			if (step.stdout) console.log(`  stdout: ${step.stdout}`);
-		}
-	};
-	if (!result.ok) {
-		console.error(`Update failed: ${result.error ?? "unknown error"}`);
-		if (result.steps.length > 0) printSteps();
-		return {
-			ok: false,
-			shouldSuggestRestart: false
-		};
-	}
-	if (result.strategy === "noop") {
-		console.log(`✓ ${appName} is already up to date (${result.latestVersion ?? currentVersion})`);
+//#region src/cli/launcher/npm-runtime-update.manager.ts
+var NpmRuntimeUpdateManager = class {
+	launcherVersion;
+	now;
+	availableManifest = null;
+	constructor(options) {
+		this.options = options;
+		this.launcherVersion = options.launcherVersion ?? getPackageVersion$1();
+		this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+		this.options.layout.ensureLauncherDirs();
+		this.syncStateFromCurrentPointer();
+	}
+	getSnapshot = () => this.toSnapshotFromState(this.options.stateStore.read(), { status: this.options.stateStore.read().downloadedVersion ? "downloaded" : "idle" });
+	run = async (options = {}) => {
+		if (options.apply) return this.applyDownloadedUpdate();
+		const checkedSnapshot = await this.checkForUpdate();
+		if (options.checkOnly || checkedSnapshot.status !== "update-available") return checkedSnapshot;
+		if (options.download === false) return checkedSnapshot;
+		return await this.downloadUpdate(options.onProgress);
+	};
+	checkForUpdate = async () => {
+		const manifestUrl = this.options.resolveManifestUrl(this.options.channel);
+		if (!this.options.updateService.hasSignatureVerifier()) return this.toSnapshotFromState(this.options.stateStore.read(), {
+			status: "blocked",
+			installationKind: "npm-runtime-bundle",
+			blockReason: "signature-verification-unavailable",
+			recoveryCommand: "Set NEXTCLAW_UPDATE_BUNDLE_PUBLIC_KEY or NEXTCLAW_UPDATE_BUNDLE_PUBLIC_KEY_PATH",
+			errorMessage: "Runtime bundle updates require a configured update public key."
+		});
+		if (!manifestUrl) return this.toSnapshotFromState(this.options.stateStore.read(), {
+			status: "blocked",
+			installationKind: "npm-runtime-bundle",
+			blockReason: "unsupported-installation",
+			recoveryCommand: "Set NEXTCLAW_UPDATE_MANIFEST_URL or NEXTCLAW_UPDATE_MANIFEST_BASE_URL",
+			errorMessage: "Runtime bundle update manifest URL is not configured."
+		});
+		const checkedAt = this.now().toISOString();
+		const state = this.options.stateStore.update((current) => ({
+			...current,
+			channel: this.options.channel,
+			lastUpdateCheckAt: checkedAt
+		}));
+		const availableUpdate = await this.options.updateService.checkForUpdate(manifestUrl, state.currentVersion, state.badVersions);
+		return this.toSnapshotAfterCheck(availableUpdate, this.options.stateStore.read());
+	};
+	downloadUpdate = async (onProgress) => {
+		const manifest = this.availableManifest ?? await this.ensureAvailableManifest();
+		const downloaded = await this.options.updateService.downloadAndInstallUpdate(manifest, onProgress);
+		const state = this.options.stateStore.update((current) => ({
+			...current,
+			downloadedVersion: downloaded.downloadedVersion,
+			downloadedReleaseNotesUrl: downloaded.manifest.releaseNotesUrl
+		}));
+		await this.options.bundleService.pruneRetainedArtifacts();
+		return this.toSnapshotFromState(state, {
+			status: "downloaded",
+			availableVersion: downloaded.downloadedVersion,
+			downloadedVersion: downloaded.downloadedVersion,
+			minimumHostVersion: downloaded.manifest.minimumLauncherVersion,
+			releaseNotesUrl: downloaded.manifest.releaseNotesUrl,
+			canApplyInApp: true,
+			requiresRestart: false
+		});
+	};
+	applyDownloadedUpdate = () => {
+		const downloadedVersion = this.options.stateStore.read().downloadedVersion?.trim();
+		if (!downloadedVersion) throw new Error("No downloaded npm runtime update is ready to apply.");
+		this.options.bundleService.activateVersion(downloadedVersion);
+		this.availableManifest = null;
+		return this.toSnapshotFromState(this.options.stateStore.read(), {
+			status: "restart-required",
+			availableVersion: null,
+			downloadedVersion: null,
+			releaseNotesUrl: null,
+			canApplyInApp: false,
+			requiresRestart: true
+		});
+	};
+	ensureAvailableManifest = async () => {
+		const snapshot = await this.checkForUpdate();
+		if (!this.availableManifest) {
+			if (snapshot.downloadedVersion) throw new Error(`Version ${snapshot.downloadedVersion} has already been downloaded and is ready to apply.`);
+			throw new Error("No npm runtime update is currently available.");
+		}
+		return this.availableManifest;
+	};
+	toSnapshotAfterCheck = (availableUpdate, state) => {
+		if (state.downloadedVersion) {
+			this.availableManifest = availableUpdate?.kind === "runtime-bundle-update" ? availableUpdate.manifest : this.availableManifest;
+			return this.toSnapshotFromState(state, {
+				status: "downloaded",
+				availableVersion: availableUpdate?.kind === "runtime-bundle-update" ? availableUpdate.manifest.latestVersion : state.downloadedVersion,
+				minimumHostVersion: availableUpdate?.kind === "runtime-bundle-update" ? availableUpdate.manifest.minimumLauncherVersion : null,
+				canApplyInApp: true,
+				requiresRestart: false
+			});
+		}
+		if (!availableUpdate) {
+			this.availableManifest = null;
+			return this.toSnapshotFromState(state, {
+				status: "up-to-date",
+				availableVersion: null,
+				downloadedVersion: null,
+				releaseNotesUrl: null
+			});
+		}
+		if (availableUpdate.kind === "host-update-required") {
+			this.availableManifest = null;
+			return this.toSnapshotFromState(state, {
+				status: "blocked",
+				availableVersion: availableUpdate.manifest.latestVersion,
+				minimumHostVersion: availableUpdate.manifest.minimumLauncherVersion,
+				releaseNotesUrl: availableUpdate.manifest.releaseNotesUrl,
+				blockReason: "host-too-old",
+				recoveryCommand: "npm install -g nextclaw@latest",
+				errorMessage: `NextClaw npm launcher ${this.launcherVersion} is too old for runtime bundle ${availableUpdate.manifest.latestVersion}.`
+			});
+		}
+		if (availableUpdate.kind === "quarantined-bad-version") {
+			this.availableManifest = null;
+			return this.toSnapshotFromState(state, {
+				status: "failed",
+				availableVersion: availableUpdate.manifest.latestVersion,
+				minimumHostVersion: availableUpdate.manifest.minimumLauncherVersion,
+				releaseNotesUrl: availableUpdate.manifest.releaseNotesUrl,
+				errorMessage: `Version ${availableUpdate.manifest.latestVersion} was quarantined after a failed launch.`
+			});
+		}
+		this.availableManifest = availableUpdate.manifest;
+		return this.toSnapshotFromState(state, {
+			status: "update-available",
+			availableVersion: availableUpdate.manifest.latestVersion,
+			minimumHostVersion: availableUpdate.manifest.minimumLauncherVersion,
+			releaseNotesUrl: availableUpdate.manifest.releaseNotesUrl
+		});
+	};
+	syncStateFromCurrentPointer = () => {
+		const currentPointer = this.options.layout.readCurrentPointer();
+		if (!currentPointer) return;
+		this.options.stateStore.update((state) => ({
+			...state,
+			currentVersion: state.currentVersion ?? currentPointer.version
+		}));
+	};
+	toSnapshotFromState = (state, patch) => {
+		const hasDownloadedVersion = Boolean(state.downloadedVersion);
+		const { status } = patch;
 		return {
-			ok: true,
-			shouldSuggestRestart: false
+			installationKind: "npm-runtime-bundle",
+			channel: state.channel,
+			hostVersion: this.launcherVersion,
+			currentVersion: state.currentVersion,
+			availableVersion: null,
+			downloadedVersion: state.downloadedVersion,
+			minimumHostVersion: null,
+			releaseNotesUrl: state.downloadedReleaseNotesUrl,
+			lastCheckedAt: state.lastUpdateCheckAt,
+			progress: null,
+			canAutoDownload: state.updatePreferences.autoDownload,
+			canApplyInApp: hasDownloadedVersion,
+			requiresRestart: false,
+			blockReason: null,
+			recoveryCommand: null,
+			errorMessage: null,
+			preferences: { ...state.updatePreferences },
+			...patch,
+			status
 		};
-	}
-	const versionAfter = result.latestVersion ?? readInstalledVersion();
-	console.log(`✓ Update complete (${result.strategy})`);
-	if (versionAfter === currentVersion) console.log(`Version unchanged: ${currentVersion}`);
-	else console.log(`Version updated: ${currentVersion} -> ${versionAfter}`);
-	return {
-		ok: true,
-		shouldSuggestRestart: true
 	};
-}
+};
 //#endregion
-//#region src/cli/shared/utils/cli.utils.ts
-function resolveUiConfig(config, overrides) {
-	return {
-		...config.ui ?? {
-			enabled: false,
-			host: "127.0.0.1",
-			port: 55667,
-			open: false
-		},
-		...overrides ?? {}
+//#region src/cli/launcher/npm-runtime-update.service.ts
+var NpmRuntimeUpdateService = class {
+	platform;
+	arch;
+	fetchImpl;
+	manifestReader;
+	bundlePublicKey;
+	now;
+	constructor(options) {
+		this.options = options;
+		this.platform = options.platform ?? process.platform;
+		this.arch = options.arch ?? process.arch;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+		this.manifestReader = options.manifestReader ?? new UpdateManifestReader();
+		this.bundlePublicKey = this.parseBundlePublicKey(options.bundlePublicKey);
+		this.now = options.now ?? Date.now;
+	}
+	hasSignatureVerifier = () => Boolean(this.bundlePublicKey);
+	checkForUpdate = async (manifestUrl, currentVersion, badVersions = []) => {
+		const manifest = await this.fetchManifest(manifestUrl);
+		if (currentVersion && compareNpmRuntimeVersions(manifest.latestVersion, currentVersion) <= 0) return null;
+		if (compareNpmRuntimeVersions(this.options.launcherVersion, manifest.minimumLauncherVersion) < 0) return {
+			kind: "host-update-required",
+			manifest
+		};
+		if (badVersions.includes(manifest.latestVersion)) return {
+			kind: "quarantined-bad-version",
+			manifest
+		};
+		return {
+			kind: "runtime-bundle-update",
+			manifest
+		};
 	};
-}
-function resolveUiApiBase(host, port) {
-	return resolveLocalUiBaseUrl({
-		host,
-		port
-	});
-}
-function isLoopbackHost(host) {
-	const normalized = host.trim().toLowerCase();
-	return normalized === "127.0.0.1" || normalized === "localhost" || normalized === "::1";
-}
-const PUBLIC_IP_CHECK_URLS = ["https://api.ipify.org", "https://ifconfig.me/ip"];
-async function fetchPublicIpFrom(url, timeoutMs) {
-	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(), timeoutMs);
-	try {
-		const response = await fetch(url, {
-			signal: controller.signal,
-			headers: { Accept: "text/plain" }
+	downloadAndInstallUpdate = async (manifest, reportProgress) => {
+		const bytes = await this.downloadBundleBytes(manifest, reportProgress);
+		const stagingRoot = join(this.options.layout.getStagingDir(), `download-${manifest.latestVersion}-${this.now()}`);
+		await rm(stagingRoot, {
+			recursive: true,
+			force: true
 		});
-		if (!response.ok) return null;
-		const text = (await response.text()).trim();
-		return isIP(text) ? text : null;
-	} catch {
-		return null;
-	} finally {
-		clearTimeout(timer);
-	}
-}
-async function resolvePublicIp(timeoutMs = 1500) {
-	for (const endpoint of PUBLIC_IP_CHECK_URLS) {
-		const candidate = await fetchPublicIpFrom(endpoint, timeoutMs);
-		if (candidate) return candidate;
-	}
-	return null;
-}
-function resolveServiceLogPath() {
-	return resolve(getLogsPath(), "service.log");
-}
-function isProcessRunning(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function waitForExit(pid, timeoutMs) {
-	const start = Date.now();
-	while (Date.now() - start < timeoutMs) {
-		if (!isProcessRunning(pid)) return true;
-		await new Promise((resolve) => setTimeout(resolve, 200));
-	}
-	return !isProcessRunning(pid);
-}
-function findNearestPackageManifest(startDir, expectedName) {
-	let current = resolve(startDir);
-	while (current.length > 0) {
-		const pkgPath = join(current, "package.json");
-		if (existsSync(pkgPath)) try {
-			const raw = readFileSync(pkgPath, "utf-8");
-			const parsed = JSON.parse(raw);
-			if (!expectedName || parsed.name === expectedName) return {
-				rootDir: current,
-				version: typeof parsed.version === "string" ? parsed.version : void 0
+		mkdirSync(stagingRoot, { recursive: true });
+		try {
+			const zip = await JSZip.loadAsync(bytes);
+			const entries = Object.values(zip.files);
+			await Promise.all(entries.map(async (entry) => {
+				const targetPath = resolve(stagingRoot, entry.name);
+				const resolvedStagingRoot = resolve(stagingRoot);
+				if (targetPath !== resolvedStagingRoot && !targetPath.startsWith(`${resolvedStagingRoot}${sep}`)) throw new Error(`runtime bundle archive contains invalid path: ${entry.name}`);
+				if (entry.dir) {
+					mkdirSync(targetPath, { recursive: true });
+					return;
+				}
+				mkdirSync(dirname(targetPath), { recursive: true });
+				writeFileSync(targetPath, Buffer.from(await entry.async("uint8array")));
+			}));
+			const bundleRoot = this.findBundleRoot(stagingRoot);
+			const installedBundle = await this.options.bundleService.installFromDirectory(bundleRoot);
+			return {
+				manifest,
+				downloadedVersion: installedBundle.manifest.bundleVersion,
+				bundleDirectory: installedBundle.bundleDirectory
 			};
-		} catch {}
-		const parent = resolve(current, "..");
-		if (parent === current) break;
-		current = parent;
-	}
-	return null;
-}
-function resolveUiStaticDir(importMetaUrl = import.meta.url) {
-	if (process.env.NEXTCLAW_DISABLE_STATIC_UI === "1") return null;
-	const envDir = process.env.NEXTCLAW_UI_STATIC_DIR;
-	if (envDir) return existsSync(join(envDir, "index.html")) ? envDir : null;
-	const pkgRoot = findNearestPackageManifest(resolve(fileURLToPath(new URL(".", importMetaUrl))), "nextclaw")?.rootDir;
-	if (!pkgRoot) return null;
-	const bundledDir = join(pkgRoot, "ui-dist");
-	return existsSync(join(bundledDir, "index.html")) ? bundledDir : null;
-}
-function openBrowser(url) {
-	const platform = process.platform;
-	let command;
-	let args;
-	if (platform === "darwin") {
-		command = "open";
-		args = [url];
-	} else if (platform === "win32") {
-		command = "cmd";
-		args = [
-			"/c",
-			"start",
-			"",
-			url
-		];
-	} else {
-		command = "xdg-open";
-		args = [url];
-	}
-	if (!findExecutableOnPath(command)) return false;
-	try {
-		spawn(command, args, {
-			stdio: "ignore",
-			detached: true,
-			env: createExternalCommandEnv(process.env)
-		}).unref();
-		return true;
-	} catch {
-		return false;
-	}
-}
-function normalizePathEntries(rawPath, platform) {
-	const delimiter = platform === "win32" ? ";" : ":";
-	return rawPath.split(delimiter).map((entry) => entry.trim().replace(/^"+|"+$/g, "")).filter(Boolean);
-}
-function normalizeWindowsPathExt(rawPathExt) {
-	const source = rawPathExt && rawPathExt.trim().length > 0 ? rawPathExt : ".COM;.EXE;.BAT;.CMD";
-	const unique = /* @__PURE__ */ new Set();
-	for (const ext of source.split(";")) {
-		const trimmed = ext.trim();
-		if (!trimmed) continue;
-		const normalized = trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
-		unique.add(normalized.toUpperCase());
-	}
-	return [...unique];
-}
-function hasFileExtension(binary) {
-	return binary.lastIndexOf(".") > Math.max(binary.lastIndexOf("/"), binary.lastIndexOf("\\"));
-}
-function findExecutableOnPath(binary, env = process.env, platform = process.platform) {
-	const target = binary.trim();
-	if (!target) return null;
-	if (target.includes("/") || target.includes("\\")) return existsSync(target) ? target : null;
-	const rawPath = env.PATH ?? env.Path ?? env.path ?? "";
-	if (!rawPath.trim()) return null;
-	const entries = normalizePathEntries(rawPath, platform);
-	if (entries.length === 0) return null;
-	for (const dir of entries) {
-		const direct = join(dir, target);
-		if (existsSync(direct)) return direct;
-		if (platform !== "win32" || hasFileExtension(target)) continue;
-		for (const ext of normalizeWindowsPathExt(env.PATHEXT)) {
-			const withExt = join(dir, `${target}${ext}`);
-			if (existsSync(withExt)) return withExt;
+		} catch (error) {
+			await rm(stagingRoot, {
+				recursive: true,
+				force: true
+			});
+			throw error;
 		}
-	}
-	return null;
+	};
+	downloadBundleBytes = async (manifest, reportProgress) => {
+		const response = await this.fetchBundle(manifest.bundleUrl);
+		const bytes = await this.readResponseBytes(response, reportProgress);
+		const sha256 = createHash("sha256").update(bytes).digest("hex");
+		if (sha256 !== manifest.bundleSha256) throw new Error(`runtime bundle sha256 mismatch: expected ${manifest.bundleSha256} but got ${sha256}`);
+		this.assertBundleSignature(manifest, bytes);
+		return bytes;
+	};
+	fetchManifest = async (manifestUrl) => {
+		if (manifestUrl.startsWith("file://")) {
+			const manifest = this.manifestReader.parse(JSON.parse(readFileSync(fileURLToPath(manifestUrl), "utf8")), manifestUrl);
+			return this.verifyManifest(manifest, manifestUrl);
+		}
+		const response = await this.fetchImpl(manifestUrl);
+		if (!response.ok) throw new Error(`runtime update manifest request failed with status ${response.status}`);
+		const manifest = this.manifestReader.parse(await response.json(), manifestUrl);
+		return this.verifyManifest(manifest, manifestUrl);
+	};
+	verifyManifest = (manifest, manifestUrl) => {
+		if (manifest.hostKind && manifest.hostKind !== "npm-runtime-bundle") throw new Error(`runtime update manifest hostKind mismatch: expected npm-runtime-bundle but got ${manifest.hostKind}`);
+		if (manifest.channel !== "stable" && manifest.channel !== "beta") throw new Error(`runtime update manifest channel is unsupported: ${manifest.channel}`);
+		if (manifest.platform !== this.platform) throw new Error(`runtime update manifest platform mismatch: expected ${this.platform} but got ${manifest.platform}`);
+		if (manifest.arch !== this.arch) throw new Error(`runtime update manifest arch mismatch: expected ${this.arch} but got ${manifest.arch}`);
+		this.assertManifestSignature(manifest);
+		return manifest;
+	};
+	fetchBundle = async (bundleUrl) => {
+		if (bundleUrl.startsWith("file://")) {
+			const bytes = readFileSync(fileURLToPath(bundleUrl));
+			return new Response(bytes, {
+				status: 200,
+				headers: { "content-length": String(bytes.byteLength) }
+			});
+		}
+		const response = await this.fetchImpl(bundleUrl);
+		if (!response.ok) throw new Error(`runtime bundle download failed with status ${response.status}`);
+		return response;
+	};
+	readResponseBytes = async (response, reportProgress) => {
+		const totalBytes = this.readContentLength(response);
+		if (!response.body) {
+			const bytes = Buffer.from(await response.arrayBuffer());
+			this.reportDownloadProgress(reportProgress, bytes.byteLength, totalBytes ?? bytes.byteLength);
+			return bytes;
+		}
+		const reader = response.body.getReader();
+		const chunks = [];
+		let downloadedBytes = 0;
+		this.reportDownloadProgress(reportProgress, downloadedBytes, totalBytes);
+		while (true) {
+			const next = await reader.read();
+			if (next.done) break;
+			chunks.push(next.value);
+			downloadedBytes += next.value.byteLength;
+			this.reportDownloadProgress(reportProgress, downloadedBytes, totalBytes);
+		}
+		return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
+	};
+	readContentLength = (response) => {
+		const raw = response.headers.get("content-length");
+		if (!raw) return null;
+		const parsed = Number(raw);
+		return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+	};
+	reportDownloadProgress = (reportProgress, downloadedBytes, totalBytes) => {
+		reportProgress?.({
+			downloadedBytes,
+			totalBytes,
+			percent: totalBytes && totalBytes > 0 ? Math.min(100, Math.round(downloadedBytes / totalBytes * 100)) : null
+		});
+	};
+	findBundleRoot = (stagingRoot) => {
+		if (existsSync(join(stagingRoot, "manifest.json"))) return stagingRoot;
+		const entries = readDirectoryNames(stagingRoot).filter((entry) => existsSync(join(stagingRoot, entry, "manifest.json")));
+		if (entries.length === 1) return join(stagingRoot, entries[0]);
+		throw new Error(`runtime bundle archive does not contain exactly one manifest root under ${stagingRoot}`);
+	};
+	parseBundlePublicKey = (publicKey) => {
+		const normalizedKey = publicKey?.trim();
+		if (!normalizedKey) return null;
+		const pemOrEscapedPem = normalizedKey.replaceAll("\\n", "\n");
+		if (pemOrEscapedPem.includes("BEGIN PUBLIC KEY")) return createPublicKey(pemOrEscapedPem);
+		return createPublicKey({
+			key: Buffer.from(normalizedKey, "base64"),
+			format: "der",
+			type: "spki"
+		});
+	};
+	assertManifestSignature = (manifest) => {
+		if (!this.bundlePublicKey) throw new Error("runtime update manifest signature verification requires bundlePublicKey");
+		const signature = Buffer.from(manifest.manifestSignature, "base64");
+		if (!verify(null, Buffer.from(serializeUnsignedUpdateManifest(manifest)), this.bundlePublicKey, signature)) throw new Error(`runtime update manifest signature verification failed for ${manifest.latestVersion}`);
+	};
+	assertBundleSignature = (manifest, bytes) => {
+		if (!this.bundlePublicKey) throw new Error("runtime bundle signature verification requires bundlePublicKey");
+		const signature = Buffer.from(manifest.bundleSignature, "base64");
+		if (!verify(null, bytes, this.bundlePublicKey, signature)) throw new Error(`runtime bundle signature verification failed for ${manifest.latestVersion}`);
+	};
+};
+function readDirectoryNames(directory) {
+	return readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
 }
-function getPackageVersion$1() {
-	const cliDir = resolve(fileURLToPath(new URL(".", import.meta.url)));
-	return findNearestPackageManifest(cliDir, "nextclaw")?.version ?? findNearestPackageManifest(cliDir)?.version ?? getPackageVersion();
+//#endregion
+//#region src/cli/launcher/npm-runtime-update-source.service.ts
+const DEFAULT_NPM_RUNTIME_UPDATE_BASE_URL = "https://Peiiii.github.io/nextclaw/npm-runtime-updates";
+function normalizeOptionalString$8(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : null;
 }
-function printAgentResponse(response) {
-	console.log("\n" + response + "\n");
+function normalizeChannel(value) {
+	return typeof value === "string" && value.trim().toLowerCase() === "beta" ? "beta" : "stable";
 }
-async function prompt(rl, question) {
-	rl.setPrompt(question);
-	rl.prompt();
-	return new Promise((resolve) => {
-		rl.once("line", (line) => resolve(line));
-	});
+function resolvePackagedPublicKeyPath() {
+	return resolve(dirname(fileURLToPath(import.meta.url)), "../../..", "resources", "update-bundle-public.pem");
 }
-//#endregion
-//#region src/cli/shared/services/update/self-update.service.ts
-const DEFAULT_TIMEOUT_MS = 20 * 6e4;
-function runSelfUpdate(options = {}) {
-	const steps = [];
-	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	const updateCommand = options.updateCommand ?? process.env.NEXTCLAW_UPDATE_COMMAND?.trim();
-	const packageName = options.packageName ?? "nextclaw";
-	const currentVersion = options.currentVersion?.trim() || null;
-	const resolveShellCommand = (command) => {
-		if (process.platform === "win32") return {
-			cmd: process.env.ComSpec || "cmd.exe",
-			args: [
-				"/d",
-				"/s",
-				"/c",
-				command
-			]
-		};
-		return {
-			cmd: process.env.SHELL || "sh",
-			args: ["-c", command]
-		};
+var NpmRuntimeUpdateSourceService = class {
+	env;
+	platform;
+	arch;
+	constructor(options = {}) {
+		this.env = options.env ?? process.env;
+		this.platform = options.platform ?? process.platform;
+		this.arch = options.arch ?? process.arch;
+	}
+	resolveChannel = (explicitChannel) => {
+		return normalizeChannel(explicitChannel ?? this.env.NEXTCLAW_UPDATE_CHANNEL);
 	};
-	const runStep = (cmd, args, cwd) => {
-		const result = spawnSync(cmd, args, {
-			cwd,
-			env: createExternalCommandEnv(process.env),
-			encoding: "utf-8",
-			timeout: timeoutMs,
-			stdio: "pipe"
-		});
-		const stdout = (result.stdout ?? "").toString().slice(0, 4e3);
-		const stderr = (result.stderr ?? "").toString().slice(0, 4e3);
-		steps.push({
-			cmd,
-			args,
-			cwd,
-			code: result.status,
-			stdout,
-			stderr
-		});
-		return {
-			ok: result.status === 0,
-			code: result.status,
-			stdout,
-			stderr
-		};
+	resolveManifestUrl = (channel, explicitManifestUrl) => {
+		const manifestUrl = normalizeOptionalString$8(explicitManifestUrl) ?? normalizeOptionalString$8(this.env.NEXTCLAW_UPDATE_MANIFEST_URL);
+		if (manifestUrl) return manifestUrl;
+		const baseUrl = normalizeOptionalString$8(this.env.NEXTCLAW_UPDATE_MANIFEST_BASE_URL) ?? DEFAULT_NPM_RUNTIME_UPDATE_BASE_URL;
+		return new URL(`${channel}/manifest-${channel}-${this.platform}-${this.arch}.json`, `${baseUrl.replace(/\/+$/, "")}/`).toString();
 	};
-	const parseLatestVersion = (raw) => {
-		const trimmed = raw.trim();
-		if (!trimmed) return null;
-		try {
-			const parsed = JSON.parse(trimmed);
-			return typeof parsed === "string" && parsed.trim() ? parsed.trim() : null;
-		} catch {
-			return trimmed;
+	resolveBundlePublicKey = () => {
+		const explicitPublicKey = normalizeOptionalString$8(this.env.NEXTCLAW_UPDATE_BUNDLE_PUBLIC_KEY);
+		if (explicitPublicKey) return explicitPublicKey;
+		const publicKeyPath = normalizeOptionalString$8(this.env.NEXTCLAW_UPDATE_BUNDLE_PUBLIC_KEY_PATH);
+		if (!publicKeyPath || !existsSync(publicKeyPath)) {
+			const packagedPublicKeyPath = resolvePackagedPublicKeyPath();
+			return existsSync(packagedPublicKeyPath) ? readFileSync(packagedPublicKeyPath, "utf8").trim() : null;
 		}
+		return readFileSync(publicKeyPath, "utf8").trim();
 	};
-	if (updateCommand) {
-		const cwd = options.cwd ? resolve(options.cwd) : process.cwd();
-		const shellCommand = resolveShellCommand(updateCommand);
-		if (!runStep(shellCommand.cmd, shellCommand.args, cwd).ok) return {
-			ok: false,
-			error: "update command failed",
-			strategy: "command",
-			steps
-		};
-		return {
-			ok: true,
-			strategy: "command",
-			steps
-		};
-	}
-	const npmExecutable = findExecutableOnPath("npm");
-	if (npmExecutable) {
-		const cwd = options.cwd ? resolve(options.cwd) : process.cwd();
-		const latestVersionStep = runStep(npmExecutable, [
-			"view",
-			packageName,
-			"version",
-			"--json"
-		], cwd);
-		const latestVersion = latestVersionStep.ok ? parseLatestVersion(latestVersionStep.stdout) : null;
-		if (latestVersion && currentVersion && latestVersion === currentVersion) return {
-			ok: true,
-			strategy: "noop",
-			latestVersion,
-			steps
-		};
-		if (!runStep(npmExecutable, [
-			"i",
-			"-g",
-			packageName
-		], cwd).ok) return {
-			ok: false,
-			error: `npm install -g ${packageName} failed`,
-			strategy: "npm",
-			latestVersion: latestVersion ?? void 0,
-			steps
-		};
-		return {
-			ok: true,
-			strategy: "npm",
-			latestVersion: latestVersion ?? void 0,
-			steps
-		};
-	}
-	return {
-		ok: false,
-		error: "no update strategy available",
-		strategy: "none",
-		steps
+};
+//#endregion
+//#region src/cli/launcher/npm-runtime-update-command.service.ts
+var NpmRuntimeUpdateCommandService = class {
+	run = async (opts) => {
+		const snapshot = await this.runManaged(opts);
+		if (opts.json) console.log(JSON.stringify(snapshot, null, 2));
+		else this.printSnapshot(snapshot);
+		return snapshot;
+	};
+	runManaged = async (opts) => {
+		const source = new NpmRuntimeUpdateSourceService();
+		const channel = source.resolveChannel(opts.channel);
+		const manifestUrl = source.resolveManifestUrl(channel, opts.manifestUrl);
+		const layout = new NpmRuntimeBundleLayoutStore();
+		const stateStore = new NpmRuntimeUpdateStateStore(layout.getStatePath());
+		const launcherVersion = getPackageVersion$1();
+		const bundleService = new NpmRuntimeBundleService({
+			layout,
+			stateStore,
+			launcherVersion
+		});
+		return await new NpmRuntimeUpdateManager({
+			layout,
+			stateStore,
+			bundleService,
+			updateService: new NpmRuntimeUpdateService({
+				layout,
+				bundleService,
+				launcherVersion,
+				bundlePublicKey: source.resolveBundlePublicKey() ?? void 0
+			}),
+			resolveManifestUrl: () => manifestUrl,
+			launcherVersion,
+			channel
+		}).run({
+			apply: Boolean(opts.apply),
+			checkOnly: Boolean(opts.check),
+			download: opts.download === void 0 ? true : Boolean(opts.download),
+			onProgress: opts.json ? void 0 : this.printProgress
+		});
+	};
+	printProgress = (progress) => {
+		const percent = progress.percent === null ? "" : ` ${progress.percent}%`;
+		const total = progress.totalBytes === null ? "" : ` / ${progress.totalBytes} bytes`;
+		process.stdout.write(`\rDownloading${percent} (${progress.downloadedBytes} bytes${total})`);
+		if (progress.percent === 100) process.stdout.write("\n");
+	};
+	printSnapshot = (snapshot) => {
+		if (snapshot.status === "blocked") {
+			console.error(`Update blocked: ${snapshot.errorMessage ?? snapshot.blockReason ?? "unknown reason"}`);
+			if (snapshot.recoveryCommand) console.error(`Recovery: ${snapshot.recoveryCommand}`);
+			return;
+		}
+		if (snapshot.status === "failed") {
+			console.error(`Update failed: ${snapshot.errorMessage ?? "unknown error"}`);
+			return;
+		}
+		if (snapshot.status === "up-to-date") {
+			console.log(`NextClaw runtime is already up to date (${snapshot.currentVersion ?? snapshot.hostVersion ?? "unknown"}).`);
+			return;
+		}
+		if (snapshot.status === "downloaded") {
+			console.log(`Runtime update downloaded: ${snapshot.downloadedVersion ?? snapshot.availableVersion}`);
+			console.log("Run `nextclaw update --apply` to switch to the downloaded runtime.");
+			return;
+		}
+		if (snapshot.status === "restart-required") {
+			console.log(`Runtime update applied: ${snapshot.currentVersion}`);
+			console.log("Restart the running NextClaw service or start a new CLI process to use it.");
+			return;
+		}
+		if (snapshot.status === "update-available") {
+			console.log(`Runtime update available: ${snapshot.currentVersion ?? "none"} -> ${snapshot.availableVersion}`);
+			return;
+		}
+		console.log(`Update status: ${snapshot.status}`);
 	};
-}
+};
 //#endregion
 //#region src/cli/shared/stores/managed-service-state.store.ts
 var ManagedServiceStateStore = class {
@@ -8527,7 +8670,8 @@ function buildLegacyUserContent(parts, options = {}) {
 }
 function buildLegacyAssistantMessages(message, timestamp) {
 	const textContent = extractTextFromNcpMessage(message);
-	const reasoningContent = message.parts.filter((part) => part.type === "reasoning").map((part) => part.text).join("");
+	const reasoningParts = message.parts.filter((part) => part.type === "reasoning");
+	const reasoningContent = reasoningParts.map((part) => part.text).join("");
 	const toolInvocations = message.parts.filter((part) => part.type === "tool-invocation");
 	const assistantMessage = {
 		role: "assistant",
@@ -8537,7 +8681,7 @@ function buildLegacyAssistantMessages(message, timestamp) {
 		ncp_parts: structuredClone(message.parts)
 	};
 	if (typeof message.metadata?.reply_to === "string" && message.metadata.reply_to.trim().length > 0) assistantMessage.reply_to = message.metadata.reply_to.trim();
-	if (reasoningContent.length > 0) assistantMessage.reasoning_content = reasoningContent;
+	if (reasoningParts.length > 0) assistantMessage.reasoning_content = reasoningContent;
 	if (toolInvocations.length > 0) assistantMessage.tool_calls = toolInvocations.map((toolInvocation, index) => ({
 		id: toolInvocation.toolCallId ?? `${message.id}:tool:${index}`,
 		type: "function",
@@ -8563,11 +8707,12 @@ function buildLegacyAssistantMessages(message, timestamp) {
 }
 function buildLegacyNonAssistantMessage(message, timestamp, options) {
 	return {
-		role: message.role === "service" ? "system" : message.role,
+		role: message.role === "service" && options.serviceRole === "system" ? "system" : message.role,
 		content: buildLegacyUserContent(message.parts, options),
 		timestamp,
 		ncp_message_id: message.id,
-		ncp_parts: structuredClone(message.parts)
+		ncp_parts: structuredClone(message.parts),
+		...message.metadata ? { ncp_metadata: structuredClone(message.metadata) } : {}
 	};
 }
 function toLegacyMessages(messages, options = {}) {
@@ -8718,6 +8863,225 @@ function buildCurrentTurnState(params) {
 	};
 }
 //#endregion
+//#region src/cli/commands/ncp/context/context-compaction-timeline-message.utils.ts
+const NEXTCLAW_TIMELINE_KIND_METADATA_KEY = "nextclaw_timeline_kind";
+const CONTEXT_COMPACTION_TIMELINE_KIND = "context_compaction";
+function readTimelineMetadata(message) {
+	const rawMetadata = message?.ncp_metadata;
+	if (!rawMetadata || typeof rawMetadata !== "object" || Array.isArray(rawMetadata)) return null;
+	const metadata = rawMetadata;
+	if (metadata["nextclaw_timeline_kind"] !== "context_compaction") return null;
+	const checkpoint = metadata.checkpoint && typeof metadata.checkpoint === "object" && !Array.isArray(metadata.checkpoint) ? metadata.checkpoint : null;
+	if (!checkpoint) return null;
+	return {
+		[NEXTCLAW_TIMELINE_KIND_METADATA_KEY]: CONTEXT_COMPACTION_TIMELINE_KIND,
+		checkpoint
+	};
+}
+function buildTimelineMessage(checkpoint) {
+	return {
+		role: "service",
+		content: checkpoint.status === "compressing" ? "正在压缩较早上下文" : "较早上下文已自动压缩",
+		timestamp: checkpoint.updatedAt,
+		ncp_parts: [{
+			type: "text",
+			text: checkpoint.status === "compressing" ? "正在压缩较早上下文" : "较早上下文已自动压缩"
+		}],
+		ncp_metadata: {
+			[NEXTCLAW_TIMELINE_KIND_METADATA_KEY]: CONTEXT_COMPACTION_TIMELINE_KIND,
+			checkpoint
+		}
+	};
+}
+function buildContextCompactionTimelineNcpMessage(params) {
+	const { checkpoint, sessionId } = params;
+	const text = checkpoint.status === "compressing" ? "正在压缩较早上下文" : "较早上下文已自动压缩";
+	return {
+		id: `${sessionId}:service:context-compaction:${checkpoint.id}`,
+		sessionId,
+		role: "service",
+		status: "final",
+		timestamp: checkpoint.updatedAt,
+		parts: [{
+			type: "text",
+			text
+		}],
+		metadata: {
+			[NEXTCLAW_TIMELINE_KIND_METADATA_KEY]: CONTEXT_COMPACTION_TIMELINE_KIND,
+			checkpoint
+		}
+	};
+}
+function upsertContextCompactionTimelineMessage(params) {
+	const { checkpoint, insertBeforeMessageIds = [], session } = params;
+	const nextMessage = buildTimelineMessage(checkpoint);
+	for (let index = session.events.length - 1; index >= 0; index -= 1) {
+		const event = session.events[index];
+		const metadata = readTimelineMetadata(event?.data?.message && typeof event.data.message === "object" && !Array.isArray(event.data.message) ? event.data.message : null);
+		if (!metadata) continue;
+		event.timestamp = checkpoint.updatedAt;
+		event.data.message = nextMessage;
+		session.messages = session.messages.map((item) => {
+			return readTimelineMetadata(item)?.checkpoint.id === metadata.checkpoint.id ? nextMessage : item;
+		});
+		session.updatedAt = new Date(checkpoint.updatedAt);
+		return;
+	}
+	const event = {
+		seq: session.nextSeq,
+		type: "message.service",
+		timestamp: checkpoint.updatedAt,
+		data: { message: nextMessage }
+	};
+	session.nextSeq += 1;
+	const insertionIds = new Set(insertBeforeMessageIds);
+	const messageIndex = session.messages.findIndex((message) => typeof message.ncp_message_id === "string" && insertionIds.has(message.ncp_message_id));
+	if (messageIndex >= 0) session.messages.splice(messageIndex, 0, nextMessage);
+	else session.messages.push(nextMessage);
+	const eventIndex = session.events.findIndex((candidateEvent) => {
+		const message = candidateEvent?.data?.message && typeof candidateEvent.data.message === "object" && !Array.isArray(candidateEvent.data.message) ? candidateEvent.data.message : null;
+		return typeof message?.ncp_message_id === "string" && insertionIds.has(message.ncp_message_id);
+	});
+	if (eventIndex >= 0) session.events.splice(eventIndex, 0, event);
+	else session.events.push(event);
+	session.updatedAt = new Date(checkpoint.updatedAt);
+}
+function isContextCompactionTimelineMessage(message) {
+	return message?.metadata?.[NEXTCLAW_TIMELINE_KIND_METADATA_KEY] === CONTEXT_COMPACTION_TIMELINE_KIND;
+}
+//#endregion
+//#region src/cli/commands/ncp/context/context-compaction.service.ts
+const CONTEXT_COMPACTION_METADATA_KEY = "last_context_compaction";
+const MIN_MESSAGES_TO_COMPACT = 8;
+const RECENT_TAIL_MESSAGES = 6;
+function createCheckpointId(createdAt, coveredMessageCount) {
+	return `ctx-${createdAt.replace(/[^0-9]/g, "").slice(0, 14)}-${coveredMessageCount}`;
+}
+function isSystemMessage(message) {
+	return message?.role === "system";
+}
+var ContextCompactionService = class {
+	inputBudgetPruner = new InputBudgetPruner();
+	prepareForModelInput = (params) => {
+		const { compactionThresholdTokens, contextTokens, messages } = params;
+		const originalEstimate = this.inputBudgetPruner.estimate({
+			messages,
+			contextTokens
+		});
+		const thresholdTokens = compactionThresholdTokens ?? originalEstimate.budgetTokens;
+		if (originalEstimate.estimatedTokens < thresholdTokens) return null;
+		const { coveredMessages, keptMessages } = this.splitMessages(messages);
+		if (coveredMessages.length < MIN_MESSAGES_TO_COMPACT) return null;
+		return {
+			messages,
+			coveredMessages,
+			keptMessages,
+			originalEstimatedTokens: originalEstimate.estimatedTokens
+		};
+	};
+	compactForModelInput = async (params) => {
+		const { compactionThresholdTokens, contextTokens, generateSummary, messages, now } = params;
+		const plan = this.prepareForModelInput({
+			messages,
+			contextTokens,
+			compactionThresholdTokens
+		});
+		if (!plan) return {
+			messages,
+			checkpoint: null
+		};
+		return await this.compactPreparedForModelInput({
+			contextTokens,
+			generateSummary,
+			now,
+			plan
+		});
+	};
+	compactPreparedForModelInput = async (params) => {
+		const { contextTokens, generateSummary, now, plan } = params;
+		const { coveredMessages, keptMessages, messages, originalEstimatedTokens } = plan;
+		const createdAt = (now ?? /* @__PURE__ */ new Date()).toISOString();
+		const summary = await generateSummary({ messages: coveredMessages.map((message) => structuredClone(message)) });
+		const checkpointMessage = {
+			role: "user",
+			content: summary
+		};
+		const recentHistory = keptMessages.slice(0, -1);
+		const currentTurn = keptMessages.at(-1);
+		const projectedMessages = [
+			isSystemMessage(messages[0]) ? messages[0] : null,
+			checkpointMessage,
+			...recentHistory,
+			currentTurn
+		].filter((message) => Boolean(message));
+		const projectedEstimate = this.inputBudgetPruner.estimate({
+			messages: projectedMessages,
+			contextTokens
+		});
+		return {
+			messages: projectedMessages,
+			checkpoint: {
+				version: 1,
+				id: createCheckpointId(createdAt, coveredMessages.length),
+				status: "compressed",
+				summary,
+				coveredMessageCount: coveredMessages.length,
+				coveredSessionMessageCount: coveredMessages.length,
+				originalEstimatedTokens,
+				projectedEstimatedTokens: projectedEstimate.estimatedTokens,
+				createdAt,
+				updatedAt: createdAt
+			}
+		};
+	};
+	splitMessages = (messages) => {
+		const historyStartIndex = isSystemMessage(messages[0]) ? 1 : 0;
+		const history = messages.slice(historyStartIndex, -1);
+		const currentTurn = messages.at(-1);
+		const tailStart = Math.max(0, history.length - RECENT_TAIL_MESSAGES);
+		return {
+			coveredMessages: history.slice(0, tailStart),
+			keptMessages: [...history.slice(tailStart), ...currentTurn ? [currentTurn] : []]
+		};
+	};
+};
+function readCompressedContextCompactionCheckpoint(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const checkpoint = value;
+	return checkpoint.version === 1 && checkpoint.status === "compressed" && typeof checkpoint.summary === "string" ? checkpoint : null;
+}
+//#endregion
+//#region src/cli/commands/ncp/context/context-compaction-projection.utils.ts
+function readCompactionSummary(message) {
+	const metadata = message.metadata;
+	if (metadata?.["nextclaw_timeline_kind"] !== "context_compaction") return null;
+	return readCompressedContextCompactionCheckpoint(metadata.checkpoint)?.summary ?? null;
+}
+function projectNcpMessagesWithContextCompaction(params) {
+	const { sessionId, sessionMessages } = params;
+	let checkpointIndex = -1;
+	let summary = "";
+	for (let index = sessionMessages.length - 1; index >= 0; index -= 1) {
+		const candidateSummary = readCompactionSummary(sessionMessages[index]);
+		if (!candidateSummary) continue;
+		checkpointIndex = index;
+		summary = candidateSummary;
+		break;
+	}
+	if (checkpointIndex < 0) return sessionMessages.filter((message) => !readCompactionSummary(message)).map((message) => structuredClone(message));
+	return [{
+		id: `${sessionId}:context-compaction-summary:${sessionMessages[checkpointIndex]?.id ?? "latest"}`,
+		sessionId,
+		role: "user",
+		status: "final",
+		timestamp: sessionMessages[checkpointIndex]?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+		parts: [{
+			type: "text",
+			text: summary
+		}]
+	}, ...sessionMessages.slice(checkpointIndex + 1).filter((message) => !readCompactionSummary(message)).map((message) => structuredClone(message))];
+}
+//#endregion
 //#region src/cli/commands/ncp/session-request/session-request.tool.ts
 function readRequiredString$1(params, key) {
 	const value = params[key];
@@ -9131,14 +9495,14 @@ function resolveRequestedToolNames(metadata) {
 	if (!Array.isArray(rawValue)) return [];
 	return Array.from(new Set(rawValue.map((item) => normalizeString(item)).filter((item) => Boolean(item))));
 }
-function readRequestedAgentId(metadata) {
+function readRequestedAgentId$1(metadata) {
 	return normalizeString(metadata.agent_id)?.toLowerCase() ?? normalizeString(metadata.agentId)?.toLowerCase() ?? null;
 }
 function resolveAgentProfile(params) {
 	const { config, requestMetadata, storedAgentId } = params;
 	const { agents: { defaults }, search: searchConfig, tools: { restrictToWorkspace, exec: { timeout: execTimeoutSeconds } } } = config;
 	const defaultAgentId = resolveDefaultAgentProfileId(config);
-	const profile = findEffectiveAgentProfile(config, normalizeString(storedAgentId)?.toLowerCase() ?? readRequestedAgentId(requestMetadata) ?? defaultAgentId) ?? findEffectiveAgentProfile(config, defaultAgentId);
+	const profile = findEffectiveAgentProfile(config, normalizeString(storedAgentId)?.toLowerCase() ?? readRequestedAgentId$1(requestMetadata) ?? defaultAgentId) ?? findEffectiveAgentProfile(config, defaultAgentId);
 	if (!profile) throw new Error(`default agent profile not found: ${defaultAgentId}`);
 	return {
 		agentId: profile.id,
@@ -9204,6 +9568,16 @@ var NextclawNcpContextBuilder = class {
 		this.options = options;
 	}
 	prepare = (input, _options) => {
+		const runContext = this.prepareRunContext(input);
+		const modelMessages = this.buildModelMessages(input, _options, runContext);
+		return {
+			messages: this.pruneModelMessages(runContext, modelMessages).messages,
+			tools: buildRequestedOpenAiTools(modelMessages.toolDefinitions, runContext.requestedToolNames),
+			model: runContext.effectiveModel,
+			thinkingLevel: runContext.runtimeThinking
+		};
+	};
+	prepareRunContext = (input) => {
 		const config = this.options.getConfig();
 		const requestMetadata = mergeInputMetadata(input);
 		const session = this.options.sessionManager.getOrCreate(input.sessionId);
@@ -9230,7 +9604,6 @@ var NextclawNcpContextBuilder = class {
 			requestMetadata
 		});
 		const requestedSkills = REQUESTED_SKILLS_METADATA_READER.readSelection(requestMetadata);
-		const requestedToolNames = resolveRequestedToolNames(requestMetadata);
 		const currentTurn = buildCurrentTurnState({
 			input,
 			currentModel: effectiveModel,
@@ -9260,7 +9633,25 @@ var NextclawNcpContextBuilder = class {
 			searchConfig: profile.searchConfig,
 			workspace: effectiveWorkspace
 		});
-		const accountId = readAccountIdForHints(requestMetadata, session.metadata);
+		return {
+			accountId: readAccountIdForHints(requestMetadata, session.metadata),
+			channel,
+			chatId,
+			config,
+			currentTurn,
+			effectiveModel,
+			effectiveWorkspace,
+			profile,
+			requestMetadata,
+			requestedSkills,
+			requestedToolNames: resolveRequestedToolNames(requestMetadata),
+			runtimeThinking,
+			session,
+			sessionKey: input.sessionId
+		};
+	};
+	buildModelMessages = (input, _options, runContext) => {
+		const { accountId, channel, chatId, config, currentTurn, effectiveModel, effectiveWorkspace, profile, requestedSkills, runtimeThinking, session } = runContext;
 		const messageToolHints = this.options.resolveMessageToolHints?.({
 			sessionKey: input.sessionId,
 			channel,
@@ -9273,9 +9664,15 @@ var NextclawNcpContextBuilder = class {
 			hostWorkspace: profile.workspace,
 			sessionProjectRoot: readSessionProjectRoot(session.metadata)
 		});
-		const sessionMessages = _options?.sessionMessages ?? [];
+		const sessionMessages = projectNcpMessagesWithContextCompaction({
+			sessionId: input.sessionId,
+			sessionMessages: _options?.sessionMessages ?? []
+		});
 		const messages = contextBuilder.buildMessages({
-			history: toLegacyMessages([...sessionMessages], { assetStore: this.options.assetStore }),
+			history: toLegacyMessages([...sessionMessages], {
+				assetStore: this.options.assetStore,
+				serviceRole: "system"
+			}),
 			currentMessage: "",
 			attachments: [],
 			channel,
@@ -9292,18 +9689,19 @@ var NextclawNcpContextBuilder = class {
 			content: currentTurn.currentUserContent
 		};
 		return {
-			messages: this.inputBudgetPruner.prune({
-				messages,
-				contextTokens: profile.contextTokens
-			}).messages,
-			tools: buildRequestedOpenAiTools(toolDefinitions, requestedToolNames),
-			model: effectiveModel,
-			thinkingLevel: runtimeThinking
+			messages,
+			toolDefinitions
 		};
 	};
+	pruneModelMessages = (runContext, modelMessages) => {
+		return this.inputBudgetPruner.prune({
+			messages: modelMessages.messages,
+			contextTokens: runContext.profile.contextTokens
+		});
+	};
 };
 //#endregion
-//#region src/cli/commands/ncp/session/nextclaw-agent-session-message-adapter.ts
+//#region src/cli/commands/ncp/session/nextclaw-agent-session-message-adapter.utils.ts
 function tryParseJson(value) {
 	try {
 		return JSON.parse(value);
@@ -9366,6 +9764,10 @@ function parseLegacyToolCalls(value) {
 function createMessageId(sessionId, index, role, timestamp) {
 	return `${sessionId}:${role.trim().toLowerCase() || "message"}:${index}:${timestamp}`;
 }
+function resolveMessageId(params) {
+	const { index, message, role, sessionId, timestamp } = params;
+	return normalizeString(message.ncp_message_id) ?? createMessageId(sessionId, index, role, timestamp);
+}
 function isNcpMessagePart(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value) && typeof value.type === "string";
 }
@@ -9376,25 +9778,36 @@ function readStoredNcpParts(message) {
 	if (parts.length !== rawParts.length) return null;
 	return structuredClone(parts);
 }
+function readStoredNcpMetadata(message) {
+	const rawMetadata = message.ncp_metadata;
+	if (!rawMetadata || typeof rawMetadata !== "object" || Array.isArray(rawMetadata)) return;
+	return structuredClone(rawMetadata);
+}
 function buildAssistantMessage(params) {
-	const timestamp = ensureIsoTimestamp(params.message.timestamp, (/* @__PURE__ */ new Date()).toISOString());
-	const replyTo = typeof params.message.reply_to === "string" && params.message.reply_to.trim().length > 0 ? params.message.reply_to.trim() : void 0;
-	const storedParts = readStoredNcpParts(params.message);
+	const { index, message, sessionId } = params;
+	const timestamp = ensureIsoTimestamp(message.timestamp, (/* @__PURE__ */ new Date()).toISOString());
+	const replyTo = typeof message.reply_to === "string" && message.reply_to.trim().length > 0 ? message.reply_to.trim() : void 0;
+	const storedParts = readStoredNcpParts(message);
 	if (storedParts) return sanitizeAssistantReplyTags({
-		id: createMessageId(params.sessionId, params.index, "assistant", timestamp),
-		sessionId: params.sessionId,
+		id: resolveMessageId({
+			index,
+			message,
+			role: "assistant",
+			sessionId,
+			timestamp
+		}),
+		sessionId,
 		role: "assistant",
 		status: "final",
 		timestamp,
 		parts: storedParts,
 		metadata: replyTo ? { reply_to: replyTo } : void 0
 	});
-	const toolCalls = parseLegacyToolCalls(params.message.tool_calls);
-	const parts = [...contentToParts(params.message.content)];
-	const reasoning = normalizeString(params.message.reasoning_content);
-	if (reasoning) parts.push({
+	const toolCalls = parseLegacyToolCalls(message.tool_calls);
+	const parts = [...contentToParts(message.content)];
+	if (typeof message.reasoning_content === "string") parts.push({
 		type: "reasoning",
-		text: reasoning
+		text: message.reasoning_content
 	});
 	for (const toolCall of toolCalls) parts.push({
 		type: "tool-invocation",
@@ -9404,8 +9817,14 @@ function buildAssistantMessage(params) {
 		args: tryParseJson(toolCall.function.arguments)
 	});
 	return sanitizeAssistantReplyTags({
-		id: createMessageId(params.sessionId, params.index, "assistant", timestamp),
-		sessionId: params.sessionId,
+		id: resolveMessageId({
+			index,
+			message,
+			role: "assistant",
+			sessionId,
+			timestamp
+		}),
+		sessionId,
 		role: "assistant",
 		status: "final",
 		timestamp,
@@ -9414,23 +9833,39 @@ function buildAssistantMessage(params) {
 	});
 }
 function buildGenericMessage(params) {
-	const timestamp = ensureIsoTimestamp(params.message.timestamp, (/* @__PURE__ */ new Date()).toISOString());
-	const storedParts = readStoredNcpParts(params.message);
+	const { index, message, role, sessionId } = params;
+	const timestamp = ensureIsoTimestamp(message.timestamp, (/* @__PURE__ */ new Date()).toISOString());
+	const storedParts = readStoredNcpParts(message);
+	const storedMetadata = readStoredNcpMetadata(message);
 	if (storedParts) return {
-		id: createMessageId(params.sessionId, params.index, params.role, timestamp),
-		sessionId: params.sessionId,
-		role: params.role,
+		id: resolveMessageId({
+			index,
+			message,
+			role,
+			sessionId,
+			timestamp
+		}),
+		sessionId,
+		role,
 		status: "final",
 		timestamp,
-		parts: storedParts
+		parts: storedParts,
+		...storedMetadata ? { metadata: storedMetadata } : {}
 	};
 	return {
-		id: createMessageId(params.sessionId, params.index, params.role, timestamp),
-		sessionId: params.sessionId,
-		role: params.role,
+		id: resolveMessageId({
+			index,
+			message,
+			role,
+			sessionId,
+			timestamp
+		}),
+		sessionId,
+		role,
 		status: "final",
 		timestamp,
-		parts: contentToParts(params.message.content)
+		parts: contentToParts(message.content),
+		...storedMetadata ? { metadata: storedMetadata } : {}
 	};
 }
 function attachToolResult(target, toolCallId, result, toolName, resultContentItems) {
@@ -11215,7 +11650,293 @@ var LlmUsageRecorder = class {
 };
 const llmUsageRecorder = new LlmUsageRecorder();
 //#endregion
+//#region src/cli/commands/ncp/context/context-window-snapshot.utils.ts
+function buildContextWindowSnapshot(params) {
+	const { checkpoint, compactedUsedContextTokens, droppedHistoryCount, prunedUsedContextTokens, totalContextTokens, truncatedSystemPrompt, truncatedToolResultCount, truncatedUserMessage, usedContextTokens } = params;
+	return {
+		version: 1,
+		usedContextTokens,
+		totalContextTokens,
+		prunedUsedContextTokens,
+		availableContextTokens: Math.max(0, totalContextTokens - usedContextTokens),
+		droppedHistoryCount,
+		truncatedToolResultCount,
+		truncatedSystemPrompt,
+		truncatedUserMessage,
+		compacted: Boolean(checkpoint),
+		...checkpoint ? {
+			checkpointId: checkpoint.id,
+			compactedMessageCount: checkpoint.coveredMessageCount,
+			compactedUsedContextTokens
+		} : { compactedMessageCount: 0 },
+		updatedAt: (params.now ?? /* @__PURE__ */ new Date()).toISOString()
+	};
+}
+function buildCompressingCompactionCheckpoint(previousValue) {
+	const previous = previousValue && typeof previousValue === "object" && !Array.isArray(previousValue) ? previousValue : null;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		version: 1,
+		id: typeof previous?.id === "string" ? previous.id : `ctx-${Date.now()}`,
+		status: "compressing",
+		summary: typeof previous?.summary === "string" && previous.summary.trim().length > 0 ? previous.summary : "Compressing earlier context for the next model request.",
+		coveredMessageCount: typeof previous?.coveredMessageCount === "number" ? previous.coveredMessageCount : 0,
+		coveredSessionMessageCount: typeof previous?.coveredSessionMessageCount === "number" ? previous.coveredSessionMessageCount : 0,
+		originalEstimatedTokens: typeof previous?.originalEstimatedTokens === "number" ? previous.originalEstimatedTokens : 0,
+		projectedEstimatedTokens: typeof previous?.projectedEstimatedTokens === "number" ? previous.projectedEstimatedTokens : 0,
+		createdAt: typeof previous?.createdAt === "string" ? previous.createdAt : now,
+		updatedAt: now
+	};
+}
+//#endregion
+//#region src/cli/commands/ncp/context/context-compaction-preflight.service.ts
+const DEFAULT_COMPACTION_TRIGGER_RATIO = .8;
+const SUMMARY_MAX_TOKENS = 4e3;
+const SUMMARY_SOURCE_MAX_CHARS = 12e4;
+function readRequestedAgentId(metadata) {
+	return normalizeString(metadata.agent_id)?.toLowerCase() ?? normalizeString(metadata.agentId)?.toLowerCase() ?? null;
+}
+function resolveCompactionProfile(params) {
+	const { config, requestMetadata, storedAgentId } = params;
+	const { defaults } = config.agents;
+	const defaultAgentId = resolveDefaultAgentProfileId(config);
+	const profile = findEffectiveAgentProfile(config, normalizeString(storedAgentId)?.toLowerCase() ?? readRequestedAgentId(requestMetadata) ?? defaultAgentId) ?? findEffectiveAgentProfile(config, defaultAgentId);
+	return {
+		contextTokens: profile?.contextTokens ?? defaults.contextTokens,
+		model: profile?.model ?? defaults.model
+	};
+}
+function mergeInputMessages(params) {
+	const messages = params.sessionMessages.map((message) => structuredClone(message));
+	const seen = new Set(messages.map((message) => message.id));
+	for (const message of params.inputMessages) {
+		if (seen.has(message.id)) continue;
+		messages.push(structuredClone(message));
+	}
+	return messages;
+}
+function stringifyCompactionSource(messages) {
+	const json = JSON.stringify(messages, null, 2);
+	if (json.length <= SUMMARY_SOURCE_MAX_CHARS) return json;
+	return `${json.slice(0, SUMMARY_SOURCE_MAX_CHARS).trimEnd()}\n[truncated_source]`;
+}
+var ContextCompactionPreflightService = class {
+	compactionService = new ContextCompactionService();
+	inputBudgetPruner = new InputBudgetPruner();
+	constructor(options) {
+		this.options = options;
+	}
+	run = async (params) => {
+		const beginResult = this.begin(params);
+		if (!beginResult) return null;
+		if (!beginResult.pendingCompaction) return beginResult;
+		return await this.finish(beginResult.pendingCompaction);
+	};
+	preview = (params) => {
+		const { contextWindowOwner, requestMetadata, sessionId, sessionMessages } = params;
+		if (contextWindowOwner === "runtime") return null;
+		const session = this.options.sessionManager.getIfExists(sessionId);
+		const metadata = session?.metadata ?? requestMetadata;
+		const profile = resolveCompactionProfile({
+			config: this.options.getConfig(),
+			requestMetadata,
+			storedAgentId: session?.agentId
+		});
+		const existingCheckpoint = readCompressedContextCompactionCheckpoint(metadata[CONTEXT_COMPACTION_METADATA_KEY]);
+		return this.buildContextWindowSnapshotForMessages({
+			checkpoint: existingCheckpoint,
+			contextTokens: profile.contextTokens,
+			sessionId,
+			sessionMessages
+		});
+	};
+	begin = (params) => {
+		const { contextWindowOwner, inputMessages, requestMetadata, sessionId, sessionMessages } = params;
+		if (contextWindowOwner === "runtime") return null;
+		const session = this.options.sessionManager.getOrCreate(sessionId);
+		const profile = resolveCompactionProfile({
+			config: this.options.getConfig(),
+			requestMetadata,
+			storedAgentId: session.agentId
+		});
+		const { contextTokens } = profile;
+		const ncpMessages = mergeInputMessages({
+			inputMessages,
+			sessionMessages
+		});
+		const modelCandidateMessages = ncpMessages.filter((message) => !isContextCompactionTimelineMessage(message));
+		const existingCheckpoint = readCompressedContextCompactionCheckpoint(session.metadata[CONTEXT_COMPACTION_METADATA_KEY]);
+		const messages = toLegacyMessages(existingCheckpoint ? projectNcpMessagesWithContextCompaction({
+			sessionId,
+			sessionMessages: ncpMessages
+		}) : modelCandidateMessages);
+		const plan = existingCheckpoint ? null : this.compactionService.prepareForModelInput({
+			messages,
+			contextTokens,
+			compactionThresholdTokens: Math.floor(contextTokens * DEFAULT_COMPACTION_TRIGGER_RATIO)
+		});
+		const pruned = this.inputBudgetPruner.prune({
+			messages,
+			contextTokens
+		});
+		const checkpoint = plan ? {
+			...buildCompressingCompactionCheckpoint(session.metadata[CONTEXT_COMPACTION_METADATA_KEY]),
+			coveredMessageCount: plan.coveredMessages.length,
+			coveredSessionMessageCount: plan.coveredMessages.length,
+			originalEstimatedTokens: plan.originalEstimatedTokens,
+			projectedEstimatedTokens: pruned.estimatedTokens
+		} : existingCheckpoint;
+		const contextWindow = buildContextWindowSnapshot({
+			usedContextTokens: pruned.estimatedTokens,
+			totalContextTokens: contextTokens,
+			prunedUsedContextTokens: pruned.estimatedTokens,
+			droppedHistoryCount: pruned.droppedHistoryCount,
+			truncatedToolResultCount: pruned.truncatedToolResultCount,
+			truncatedSystemPrompt: pruned.truncatedSystemPrompt,
+			truncatedUserMessage: pruned.truncatedUserMessage,
+			checkpoint,
+			compactedUsedContextTokens: checkpoint ? pruned.estimatedTokens : void 0
+		});
+		if (plan && checkpoint) {
+			session.metadata[CONTEXT_COMPACTION_METADATA_KEY] = checkpoint;
+			upsertContextCompactionTimelineMessage({
+				session,
+				checkpoint,
+				insertBeforeMessageIds: inputMessages.map((message) => message.id)
+			});
+		}
+		this.options.sessionManager.save(session);
+		return {
+			contextWindow,
+			metadata: structuredClone(session.metadata),
+			sessionMessages: toNcpMessages(sessionId, session.messages),
+			timelineMessage: plan && checkpoint ? buildContextCompactionTimelineNcpMessage({
+				sessionId,
+				checkpoint
+			}) : null,
+			pendingCompaction: plan && checkpoint ? {
+				checkpoint,
+				contextTokens,
+				inputMessageIds: inputMessages.map((message) => message.id),
+				model: profile.model,
+				plan,
+				sessionId
+			} : null
+		};
+	};
+	buildContextWindowSnapshotForMessages = (params) => {
+		const { checkpoint, contextTokens, sessionId, sessionMessages } = params;
+		const modelCandidateMessages = sessionMessages.filter((message) => !isContextCompactionTimelineMessage(message));
+		const messages = toLegacyMessages(checkpoint ? projectNcpMessagesWithContextCompaction({
+			sessionId,
+			sessionMessages
+		}) : modelCandidateMessages);
+		const pruned = this.inputBudgetPruner.prune({
+			messages,
+			contextTokens
+		});
+		return buildContextWindowSnapshot({
+			usedContextTokens: pruned.estimatedTokens,
+			totalContextTokens: contextTokens,
+			prunedUsedContextTokens: pruned.estimatedTokens,
+			droppedHistoryCount: pruned.droppedHistoryCount,
+			truncatedToolResultCount: pruned.truncatedToolResultCount,
+			truncatedSystemPrompt: pruned.truncatedSystemPrompt,
+			truncatedUserMessage: pruned.truncatedUserMessage,
+			checkpoint,
+			compactedUsedContextTokens: checkpoint ? pruned.estimatedTokens : void 0
+		});
+	};
+	finish = async (pending) => {
+		const compacted = await this.compactionService.compactPreparedForModelInput({
+			contextTokens: pending.contextTokens,
+			plan: pending.plan,
+			generateSummary: async ({ messages }) => await this.generateSummary({
+				messages,
+				model: pending.model
+			})
+		});
+		const generatedCheckpoint = compacted.checkpoint;
+		if (!generatedCheckpoint) throw new Error("context compaction pending work did not produce a checkpoint");
+		const checkpoint = {
+			...generatedCheckpoint,
+			id: pending.checkpoint.id,
+			createdAt: pending.checkpoint.createdAt,
+			status: "compressed"
+		};
+		const pruned = this.inputBudgetPruner.prune({
+			messages: compacted.messages,
+			contextTokens: pending.contextTokens
+		});
+		const contextWindow = buildContextWindowSnapshot({
+			usedContextTokens: pruned.estimatedTokens,
+			totalContextTokens: pending.contextTokens,
+			prunedUsedContextTokens: pruned.estimatedTokens,
+			droppedHistoryCount: pruned.droppedHistoryCount,
+			truncatedToolResultCount: pruned.truncatedToolResultCount,
+			truncatedSystemPrompt: pruned.truncatedSystemPrompt,
+			truncatedUserMessage: pruned.truncatedUserMessage,
+			checkpoint,
+			compactedUsedContextTokens: pruned.estimatedTokens
+		});
+		const session = this.options.sessionManager.getOrCreate(pending.sessionId);
+		session.metadata[CONTEXT_COMPACTION_METADATA_KEY] = checkpoint;
+		upsertContextCompactionTimelineMessage({
+			session,
+			checkpoint,
+			insertBeforeMessageIds: pending.inputMessageIds
+		});
+		this.options.sessionManager.save(session);
+		return {
+			contextWindow,
+			metadata: structuredClone(session.metadata),
+			sessionMessages: toNcpMessages(pending.sessionId, session.messages),
+			timelineMessage: buildContextCompactionTimelineNcpMessage({
+				sessionId: pending.sessionId,
+				checkpoint
+			})
+		};
+	};
+	generateSummary = async (params) => {
+		if (!this.options.providerManager) throw new Error("context compaction summary generation requires a provider manager");
+		const { messages, model } = params;
+		const summary = (await this.options.providerManager.chat({
+			model,
+			maxTokens: SUMMARY_MAX_TOKENS,
+			messages: [{
+				role: "system",
+				content: [
+					"You are NextClaw's context compactor for a coding agent session.",
+					"Create a dense, structured summary that will replace earlier conversation history in a future model request.",
+					"Preserve user goals, explicit instructions, decisions, files touched or inspected, code changes, commands run, test results, failures, blockers, and exact next steps.",
+					"Do not invent facts. If something is uncertain, mark it as uncertain.",
+					"Return Markdown only. Start with '# Compressed Earlier Context'."
+				].join("\n")
+			}, {
+				role: "user",
+				content: [
+					"Compress these earlier runtime messages into a reusable checkpoint summary.",
+					"",
+					"Messages JSON:",
+					stringifyCompactionSource(messages)
+				].join("\n")
+			}]
+		})).content?.trim();
+		if (!summary) throw new Error("context compaction summary is empty");
+		return summary;
+	};
+};
+//#endregion
 //#region src/cli/commands/ncp/features/runtime/create-ui-ncp-agent.service.ts
+function createContextWindowUpdatedEvent(params) {
+	return {
+		type: NcpEventType.ContextWindowUpdated,
+		payload: {
+			sessionId: params.sessionId,
+			contextWindow: params.contextWindow
+		}
+	};
+}
 function isRecord$2(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -11271,7 +11992,7 @@ function createNativeRuntimeFactory(params, mcpToolRegistryAdapter, assetStore,
 				...sessionSearchRuntimeSupport.createAdditionalTools({ currentSessionId: context.sessionId })
 			]
 		});
-		return new DefaultNcpAgentRuntime({
+		const runtime = new DefaultNcpAgentRuntime({
 			contextBuilder: new NextclawNcpContextBuilder({
 				sessionManager: params.sessionManager,
 				toolRegistry,
@@ -11284,7 +12005,67 @@ function createNativeRuntimeFactory(params, mcpToolRegistryAdapter, assetStore,
 			stateManager,
 			reasoningNormalizationMode
 		});
+		const contextCompactionPreflight = new ContextCompactionPreflightService({
+			getConfig: params.getConfig,
+			providerManager: observedProviderManager,
+			sessionManager: params.sessionManager
+		});
+		return { run: async function* (input, options) {
+			const beginResult = contextCompactionPreflight.begin({
+				contextWindowOwner: "nextclaw",
+				inputMessages: input.messages,
+				requestMetadata: input.metadata ?? {},
+				sessionId: input.sessionId,
+				sessionMessages: stateManager.getSnapshot().messages
+			});
+			if (beginResult) {
+				setSessionMetadata(beginResult.metadata);
+				params.onSessionUpdated?.(input.sessionId);
+				yield* publishPreflightResult({
+					input,
+					result: beginResult,
+					stateManager
+				});
+				if (beginResult.pendingCompaction) {
+					const finishResult = await contextCompactionPreflight.finish(beginResult.pendingCompaction);
+					setSessionMetadata(finishResult.metadata);
+					params.onSessionUpdated?.(input.sessionId);
+					yield* publishPreflightResult({
+						input,
+						result: finishResult,
+						stateManager
+					});
+				}
+			}
+			yield* runtime.run(input, options);
+		} };
+	};
+}
+async function* publishPreflightResult(params) {
+	const { input, result, stateManager } = params;
+	const contextWindowEvent = createContextWindowUpdatedEvent({
+		contextWindow: result.contextWindow,
+		sessionId: input.sessionId
+	});
+	await stateManager.dispatch(contextWindowEvent);
+	yield contextWindowEvent;
+	if (!result.timelineMessage) return;
+	const activeRun = stateManager.getSnapshot().activeRun;
+	stateManager.hydrate({
+		sessionId: input.sessionId,
+		messages: result.sessionMessages,
+		activeRun,
+		contextWindow: result.contextWindow
+	});
+	const timelineEvent = {
+		type: NcpEventType.MessageSent,
+		payload: {
+			sessionId: input.sessionId,
+			message: result.timelineMessage
+		}
 	};
+	await stateManager.dispatch(timelineEvent);
+	yield timelineEvent;
 }
 function createResolveOpenAiToolsForRuntime(params) {
 	const { assetStore, bus, cronService, gatewayController, getConfig, getExtensionRegistry, providerManager, resolveMessageToolHints, sessionCreationService, sessionManager, sessionRequestBroker, sessionSearchRuntimeSupport, toolRegistryAdapter } = params;
@@ -11358,10 +12139,20 @@ var UiNcpAgentRuntimeService = class {
 		this.assertNotDisposed();
 		if (this.handle) return this.handle;
 		this.registerCoreRuntimes();
+		const contextWindowPreview = new ContextCompactionPreflightService({
+			getConfig: this.params.getConfig,
+			sessionManager: this.params.sessionManager
+		});
 		this.backend = new DefaultNcpAgentBackend({
 			endpointId: "nextclaw-ui-agent",
 			sessionStore: this.sessionStore,
 			onSessionRunStatusChanged: this.params.onSessionRunStatusChanged,
+			resolveSessionContextWindow: ({ messages, metadata, sessionId }) => contextWindowPreview.preview({
+				contextWindowOwner: "nextclaw",
+				requestMetadata: metadata,
+				sessionId,
+				sessionMessages: messages
+			}),
 			createRuntime: (runtimeParams) => {
 				this.pluginRuntimeRegistrationController.refreshPluginRuntimeRegistrations();
 				this.refreshConfiguredRuntimeEntries();
@@ -13991,11 +14782,9 @@ function logPluginGatewayDiagnostics(diagnostics) {
 }
 async function startGatewaySupportServices(params) {
 	if (params.cronJobs > 0) console.log(`✓ Cron: ${params.cronJobs} scheduled jobs`);
-	console.log("✓ Heartbeat: every 30m");
 	params.remoteModule?.start();
 	params.watchConfigFile();
 	await params.startCron();
-	await params.startHeartbeat();
 }
 function watchCronStoreFile(params) {
 	const cronStorePath = resolve(params.cronStorePath);
@@ -14059,13 +14848,12 @@ function finalizeLocalUiStartup(params) {
 	if (uiStartup) localUiRuntimeStore.writeCurrentProcess(uiConfig);
 }
 async function startGatewayRuntimeSupport(params) {
-	const { cronJobs, cronStorePath, reloadCronStore, remoteModule, startCron, startHeartbeat, watchConfigFile, watcherRegistry } = params;
+	const { cronJobs, cronStorePath, reloadCronStore, remoteModule, startCron, watchConfigFile, watcherRegistry } = params;
 	await startGatewaySupportServices({
 		cronJobs,
 		remoteModule,
 		watchConfigFile,
-		startCron,
-		startHeartbeat
+		startCron
 	});
 	watcherRegistry.remember(watchCronStoreFile({
 		cronStorePath,
@@ -14804,11 +15592,14 @@ var GatewayControllerImpl = class {
 	};
 	updateRun = async (params) => {
 		const versionBefore = getPackageVersion$1();
-		const result = runSelfUpdate({ timeoutMs: params.timeoutMs });
-		if (!result.ok) return {
+		params.timeoutMs;
+		const updateCommand = new NpmRuntimeUpdateCommandService();
+		const downloadedSnapshot = await updateCommand.runManaged({ download: true });
+		const snapshot = downloadedSnapshot.status === "downloaded" ? await updateCommand.runManaged({ apply: true }) : downloadedSnapshot;
+		if (snapshot.status === "blocked" || snapshot.status === "failed") return {
 			ok: false,
-			error: result.error ?? "update failed",
-			steps: result.steps,
+			error: snapshot.errorMessage ?? snapshot.blockReason ?? "update failed",
+			snapshot,
 			version: {
 				before: versionBefore,
 				after: getPackageVersion$1(),
@@ -14823,7 +15614,7 @@ var GatewayControllerImpl = class {
 			sessionKey: params.sessionKey,
 			note: params.note,
 			reason: "update.run",
-			strategy: result.strategy
+			strategy: "runtime-bundle"
 		});
 		await this.requestRestart({
 			delayMs,
@@ -14836,8 +15627,8 @@ var GatewayControllerImpl = class {
 				scheduled: true,
 				delayMs
 			},
-			strategy: result.strategy,
-			steps: result.steps,
+			strategy: "runtime-bundle",
+			snapshot,
 			version: {
 				before: versionBefore,
 				after: versionAfter,
@@ -15089,68 +15880,14 @@ function createCronJobHandler(params) {
 		return response;
 	};
 }
-function buildHeartbeatMetadata(params) {
-	return {
-		agentId: params.agentId,
-		agent_id: params.agentId,
-		channel: "cli",
-		chatId: "direct",
-		chat_id: "direct",
-		label: "heartbeat",
-		session_origin: "heartbeat"
-	};
-}
-function buildHeartbeatUserMessage(params) {
-	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-	return {
-		id: `heartbeat:user:${timestamp}`,
-		sessionId: "heartbeat",
-		role: "user",
-		status: "final",
-		timestamp,
-		parts: [{
-			type: "text",
-			text: params.content
-		}],
-		metadata: structuredClone(params.metadata)
-	};
-}
-function createHeartbeatJobHandler(params) {
-	return async (prompt) => {
-		const ncpAgent = params.resolveNcpAgent();
-		if (!ncpAgent) throw new Error("NCP agent is not ready for heartbeat execution.");
-		const metadata = buildHeartbeatMetadata({ agentId: params.resolveAgentId() });
-		return await runJobOverNcp({
-			agent: ncpAgent,
-			sessionId: "heartbeat",
-			message: buildHeartbeatUserMessage({
-				content: prompt,
-				metadata
-			}),
-			metadata,
-			missingCompletedMessageError: "heartbeat execution completed without a final assistant message",
-			runErrorMessage: "heartbeat execution failed"
-		});
-	};
-}
 //#endregion
 //#region src/cli/shared/services/gateway/service-gateway-context.service.ts
-const { ChannelManager: ChannelManager$1, CronService: CronService$1, getConfigPath: getConfigPath$2, getDataDir: getDataDir$1, getWorkspacePath: getWorkspacePath$2, HeartbeatService, loadConfig: loadConfig$3, MessageBus: MessageBus$2, ProviderManager: ProviderManager$1, resolveConfigSecrets: resolveConfigSecrets$3, resolveDefaultAgentProfileId: resolveDefaultAgentProfileId$1, saveConfig: saveConfig$1, SessionManager: SessionManager$2 } = NextclawCore;
+const { ChannelManager: ChannelManager$1, CronService: CronService$1, getConfigPath: getConfigPath$2, getDataDir: getDataDir$1, getWorkspacePath: getWorkspacePath$2, loadConfig: loadConfig$3, MessageBus: MessageBus$2, ProviderManager: ProviderManager$1, resolveConfigSecrets: resolveConfigSecrets$3, saveConfig: saveConfig$1, SessionManager: SessionManager$2 } = NextclawCore;
 function applyGatewayCapabilityState(gateway, next) {
 	gateway.pluginRegistry = next.pluginRegistry;
 	gateway.pluginChannelBindings = next.pluginChannelBindings;
 	gateway.extensionRegistry = next.extensionRegistry;
 }
-function normalizeAgentId(value) {
-	return (value ?? "").trim().toLowerCase() || "main";
-}
-function createGatewayHeartbeat(state, params) {
-	const handleHeartbeat = createHeartbeatJobHandler({
-		resolveNcpAgent: () => params.getLiveUiNcpAgent?.() ?? null,
-		resolveAgentId: () => normalizeAgentId(resolveDefaultAgentProfileId$1(resolveConfigSecrets$3(loadConfig$3(), { configPath: state.runtimeConfigPath })))
-	});
-	return new HeartbeatService(state.workspace, async (promptText) => await handleHeartbeat(promptText), 1800, true);
-}
 function createGatewayCronJobHandler(params) {
 	return createCronJobHandler({
 		resolveNcpAgent: () => params.getLiveUiNcpAgent?.() ?? null,
@@ -15253,7 +15990,6 @@ function createGatewayStartupContext(params) {
 		bus: state.bus,
 		getLiveUiNcpAgent
 	});
-	state.heartbeat = createGatewayHeartbeat(state, { getLiveUiNcpAgent });
 	return state;
 }
 //#endregion
@@ -15543,7 +16279,7 @@ function createNcpSessionRealtimeChangePublisher(params) {
 //#endregion
 //#region src/cli/commands/ncp/session/ncp-session-summary.ts
 function createNcpSessionSummary(params) {
-	const { sessionId, agentId, messages, updatedAt, status, metadata } = params;
+	const { sessionId, agentId, messages, updatedAt, status, metadata, contextWindow } = params;
 	return {
 		sessionId,
 		...agentId ? { agentId } : {},
@@ -15551,7 +16287,8 @@ function createNcpSessionSummary(params) {
 		updatedAt,
 		...messages.length > 0 ? { lastMessageAt: messages[messages.length - 1]?.timestamp ?? updatedAt } : {},
 		status,
-		...metadata ? { metadata: structuredClone(metadata) } : {}
+		...metadata ? { metadata: structuredClone(metadata) } : {},
+		...contextWindow ? { contextWindow: structuredClone(contextWindow) } : {}
 	};
 }
 //#endregion
@@ -15564,13 +16301,16 @@ function now$1() {
 	return (/* @__PURE__ */ new Date()).toISOString();
 }
 function buildUpdatedMetadata(params) {
-	if (params.patch.metadata === null) return {};
-	if (params.patch.metadata) return structuredClone(params.patch.metadata);
-	return structuredClone(params.existingMetadata ?? {});
+	const { existingMetadata, patch } = params;
+	if (patch.metadata === null) return {};
+	if (patch.metadata) return structuredClone(patch.metadata);
+	return structuredClone(existingMetadata ?? {});
 }
 var UiSessionService = class {
 	sessionStore;
+	resolveContextWindow;
 	constructor(sessionManager, options = {}) {
+		this.resolveContextWindow = options.resolveContextWindow;
 		this.sessionStore = new NextclawAgentSessionStore(sessionManager, { onSessionUpdated: options.onSessionUpdated });
 	}
 	listSessions = async (options) => {
@@ -15597,7 +16337,12 @@ var UiSessionService = class {
 			messages: session.messages,
 			updatedAt: session.updatedAt,
 			status: "idle",
-			metadata: session.metadata
+			metadata: session.metadata,
+			contextWindow: this.resolveContextWindow?.({
+				messages: session.messages,
+				metadata: session.metadata ?? {},
+				sessionId
+			}) ?? null
 		});
 	};
 	updateSession = async (sessionId, patch) => {
@@ -15673,14 +16418,27 @@ function createLatestOnlySessionChangePublisher(publishSessionChange) {
 	};
 }
 function createServiceNcpSessionRealtimeBridge(params) {
-	let publishUiEvent = params.publishUiEvent;
+	const { getConfig, publishUiEvent: initialPublishUiEvent, sessionManager } = params;
+	let publishUiEvent = initialPublishUiEvent;
 	let publishSessionChange = async (_sessionKey) => {};
 	let scheduleSessionChange = async (_sessionKey) => {};
-	const deferredSessionService = createDeferredUiNcpSessionService(new UiSessionService(params.sessionManager, { onSessionUpdated: (sessionKey) => {
-		scheduleSessionChange(sessionKey).catch((error) => {
-			console.error(`[session-realtime] failed to publish session change for ${sessionKey}: ${formatBackgroundTaskError(error)}`);
-		});
-	} }));
+	const contextWindowPreview = new ContextCompactionPreflightService({
+		getConfig,
+		sessionManager
+	});
+	const deferredSessionService = createDeferredUiNcpSessionService(new UiSessionService(sessionManager, {
+		onSessionUpdated: (sessionKey) => {
+			scheduleSessionChange(sessionKey).catch((error) => {
+				console.error(`[session-realtime] failed to publish session change for ${sessionKey}: ${formatBackgroundTaskError(error)}`);
+			});
+		},
+		resolveContextWindow: ({ messages, metadata, sessionId }) => contextWindowPreview.preview({
+			contextWindowOwner: "nextclaw",
+			requestMetadata: metadata,
+			sessionId,
+			sessionMessages: messages
+		})
+	}));
 	const publishLatestSessionChange = async (sessionKey) => {
 		await createNcpSessionRealtimeChangePublisher({
 			sessionApi: deferredSessionService.service,
@@ -16240,7 +16998,11 @@ var RuntimeCommandService = class {
 		};
 		let runtimeState = null;
 		const bootstrapStatus = createBootstrapStatus(shellContext.config.remote.enabled);
-		const ncpSessionRealtimeBridge = createServiceNcpSessionRealtimeBridge({ sessionManager: shellContext.sessionManager });
+		const getRuntimeConfig = () => resolveConfigSecrets$1(loadConfig$1(), { configPath: shellContext.runtimeConfigPath });
+		const ncpSessionRealtimeBridge = createServiceNcpSessionRealtimeBridge({
+			getConfig: getRuntimeConfig,
+			sessionManager: shellContext.sessionManager
+		});
 		const marketplaceInstaller = new ServiceMarketplaceInstaller({
 			applyLiveConfigReload,
 			runCliSubcommand: (args) => this.runCliSubcommand(args),
@@ -16256,7 +17018,7 @@ var RuntimeCommandService = class {
 			uiConfig: shellContext.uiConfig,
 			uiStaticDir: shellContext.uiStaticDir,
 			cronService: shellContext.cron,
-			getConfig: () => resolveConfigSecrets$1(loadConfig$1(), { configPath: shellContext.runtimeConfigPath }),
+			getConfig: getRuntimeConfig,
 			configPath: getConfigPath$1(),
 			productVersion: getPackageVersion$1(),
 			getPluginChannelBindings: () => runtimeState?.pluginChannelBindings ?? [],
@@ -16318,7 +17080,6 @@ var RuntimeCommandService = class {
 				scheduleReload: (reason) => gateway.reloader.scheduleReload(reason)
 			}),
 			startCron: () => gateway.cron.start(),
-			startHeartbeat: () => gateway.heartbeat.start(),
 			cronStorePath: resolve(join(NextclawCore.getDataDir(), "cron", "jobs.json")),
 			reloadCronStore: () => gateway.cron.reloadFromStore(),
 			watcherRegistry: this.fileWatchers
@@ -18149,10 +18910,6 @@ var WorkspaceManager = class {
 				source: "BOOTSTRAP.md",
 				target: "BOOTSTRAP.md"
 			},
-			{
-				source: "HEARTBEAT.md",
-				target: "HEARTBEAT.md"
-			},
 			{
 				source: "MEMORY.md",
 				target: "MEMORY.md"
@@ -19706,30 +20463,12 @@ var CliRuntime = class {
 		}
 	};
 	update = async (opts) => {
-		let timeoutMs;
-		if (opts.timeout !== void 0) {
-			const parsed = Number(opts.timeout);
-			if (!Number.isFinite(parsed) || parsed <= 0) {
-				console.error("Invalid --timeout value. Provide milliseconds (e.g. 1200000).");
-				process.exit(1);
-			}
-			timeoutMs = parsed;
-		}
 		const versionBefore = getPackageVersion$1();
-		console.log(`Current version: ${versionBefore}`);
-		const report = reportSelfUpdateResult({
-			appName: APP_NAME,
-			currentVersion: versionBefore,
-			result: runSelfUpdate({
-				timeoutMs,
-				cwd: process.cwd(),
-				currentVersion: versionBefore
-			}),
-			readInstalledVersion: getPackageVersion$1
-		});
-		if (!report.ok) process.exit(1);
+		if (!opts.json) console.log(`Current npm launcher version: ${versionBefore}`);
+		const snapshot = await new NpmRuntimeUpdateCommandService().run(opts);
+		if (snapshot.status === "blocked" || snapshot.status === "failed") process.exit(1);
 		const state = managedServiceStateStore.read();
-		if (report.shouldSuggestRestart && state && isProcessRunning(state.pid)) console.log(`Tip: restart ${APP_NAME} to apply the update.`);
+		if (snapshot.requiresRestart && state && isProcessRunning(state.pid)) console.log(`Tip: restart ${APP_NAME} to apply the update.`);
 	};
 	agentsList = (opts = {}) => {
 		this.agentCommands.agentsList(opts);
@@ -19915,7 +20654,7 @@ registerServiceCommands({
 	getServiceCommands
 });
 program.command("agent").description("Interact with the agent directly").option("-m, --message <message>", "Message to send to the agent").option("-s, --session <session>", "Session ID", "cli:default").option("--model <model>", "Session model override for this run").option("--no-markdown", "Disable Markdown rendering").action(async (opts) => runtime.agent(opts));
-program.command("update").description(`Update ${APP_NAME}`).option("--timeout <ms>", "Update command timeout in milliseconds").action(async (opts) => runtime.update(opts));
+program.command("update").description(`Check, download, or apply ${APP_NAME} runtime updates`).option("--check", "Only check for a runtime update", false).option("--download", "Download an available runtime update without applying it").option("--apply", "Apply the downloaded runtime update", false).option("--channel <channel>", "Update channel (stable or beta)").option("--manifest-url <url>", "Explicit runtime update manifest URL").option("--json", "Output JSON", false).action(async (opts) => runtime.update(opts));
 registerSkillsCommands(program, runtime.skillsCommands);
 registerAgentsCommands(program, runtime);
 const plugins = program.command("plugins").description("Manage OpenClaw-compatible plugins");