@nextclaw/kernel 0.8.0 → 0.8.2

package/dist/index.js

@@ -16,7 +16,7 @@ import { fileURLToPath } from "node:url";
 import { BUILTIN_PROVIDER_PLUGINS } from "@nextclaw/runtime";
 import { McpRegistryService, McpServerLifecycleManager } from "@nextclaw/mcp";
 import { McpNcpToolRegistryAdapter } from "@nextclaw/ncp-mcp";
-import { DefaultNcpAgentConversationStateManager, insertMessageByTimeline } from "@nextclaw/ncp-toolkit";
+import { DefaultNcpAgentConversationStateManager, insertMessageByTimeline, mergeToolExecutionTiming } from "@nextclaw/ncp-toolkit";
 import { parse } from "yaml";
 import { createInterface } from "node:readline";
 import { HttpRuntimeConfigResolver, HttpRuntimeNcpAgentRuntime } from "@nextclaw/nextclaw-ncp-runtime-http-client";
@@ -2876,17 +2876,16 @@ var AppPackageManager = class {
 	installRuntimeHooks = (hooks) => {
 		this.runtimeHooks = hooks;
 	};
-	listPackages = async () => {
-		await this.ensureBuiltInPackages();
+	start = async () => await this.ensureBuiltInPackages();
+	listPackages = async (options = {}) => {
 		const records = await this.registryService.listApps();
-		return { entries: await Promise.all(records.map(async (record) => await this.toPackageView(await this.installationService.info(record.appId)))) };
+		return { entries: await Promise.all(records.map(async (record) => await this.toPackageView(await this.installationService.info(record.appId, { measureStorageUsage: options.includeStorageUsage !== false })))) };
 	};
 	listInstalledDataOwners = async () => (await this.registryService.listApps()).map((record) => ({
 		id: record.appId,
 		name: record.name
 	}));
 	getPackage = async (appId) => {
-		await this.ensureBuiltInPackages();
 		try {
 			return await this.toPackageView(await this.installationService.info(appId));
 		} catch (error) {
@@ -2895,7 +2894,6 @@ var AppPackageManager = class {
 		}
 	};
 	listActiveComponentSources = async () => {
-		await this.ensureBuiltInPackages();
 		const records = await this.registryService.listApps();
 		return (await Promise.all(records.filter((record) => record.enabled).map(async (record) => {
 			await this.installationService.assertVersionIntegrity(record.appId, record.activeVersion);
@@ -3212,10 +3210,22 @@ var AppDataManager = class {
 	appHomeService;
 	fileLockService = new FileLockService();
 	inventoryService = new AppInstanceInventoryService();
+	reconciliationDiagnostics = [];
 	constructor(params) {
 		this.params = params;
 		this.appHomeService = new AppHomeService(params.appHomeDirectory);
 	}
+	start = async () => {
+		const workspacePath = path.resolve(this.params.getWorkspacePath());
+		const [packageDiagnostics, workspaceDiagnostics] = await Promise.all([this.inventoryService.reconcileDeletions(this.appHomeService.getInstancesDirectory()), this.inventoryService.reconcileDeletions(this.getWorkspaceInstancesRoot(workspacePath))]);
+		this.reconciliationDiagnostics = [...packageDiagnostics.map((entry) => ({
+			...entry,
+			source: "package"
+		})), ...workspaceDiagnostics.map((entry) => ({
+			...entry,
+			source: "workspace-service"
+		}))];
+	};
 	list = async () => {
 		const workspacePath = path.resolve(this.params.getWorkspacePath());
 		const workspaceInstancesRoot = this.getWorkspaceInstancesRoot(workspacePath);
@@ -3228,26 +3238,31 @@ var AppDataManager = class {
 		const packageOwners = new Map(packageList.map((entry) => [entry.id, entry]));
 		const workspaceOwnerMap = new Map(workspaceOwners.map((entry) => [entry.id, entry]));
 		const workspaceScope = this.workspaceScope(workspacePath);
+		const entries = [...packageInventory.entries.map((entry) => this.toEntry({
+			entry,
+			source: "package",
+			displayName: packageOwners.get(entry.appId)?.name ?? entry.appId,
+			active: packageOwners.has(entry.appId)
+		})), ...workspaceInventory.entries.map((entry) => this.toEntry({
+			entry,
+			source: "workspace-service",
+			displayName: workspaceOwnerMap.get(entry.appId)?.title ?? entry.appId,
+			active: workspaceOwnerMap.has(entry.appId),
+			scope: workspaceScope
+		}))].sort((left, right) => left.displayName.localeCompare(right.displayName) || left.id.localeCompare(right.id));
+		const currentDiagnostics = [...packageInventory.diagnostics.map((diagnostic) => ({
+			...diagnostic,
+			source: "package"
+		})), ...workspaceInventory.diagnostics.map((diagnostic) => ({
+			...diagnostic,
+			source: "workspace-service"
+		}))];
+		const currentDiagnosticKeys = new Set(currentDiagnostics.map((entry) => `${entry.source}:${entry.instanceDirectory}`));
+		const diagnostics = /* @__PURE__ */ new Map();
+		for (const entry of [...currentDiagnostics, ...this.reconciliationDiagnostics.filter((diagnostic) => currentDiagnosticKeys.has(`${diagnostic.source}:${diagnostic.instanceDirectory}`))]) diagnostics.set(`${entry.source}:${entry.instanceDirectory}`, entry);
 		return {
-			entries: [...packageInventory.entries.map((entry) => this.toEntry({
-				entry,
-				source: "package",
-				displayName: packageOwners.get(entry.appId)?.name ?? entry.appId,
-				active: packageOwners.has(entry.appId)
-			})), ...workspaceInventory.entries.map((entry) => this.toEntry({
-				entry,
-				source: "workspace-service",
-				displayName: workspaceOwnerMap.get(entry.appId)?.title ?? entry.appId,
-				active: workspaceOwnerMap.has(entry.appId),
-				scope: workspaceScope
-			}))].sort((left, right) => left.displayName.localeCompare(right.displayName) || left.id.localeCompare(right.id)),
-			diagnostics: [...packageInventory.diagnostics.map((entry) => ({
-				...entry,
-				source: "package"
-			})), ...workspaceInventory.diagnostics.map((entry) => ({
-				...entry,
-				source: "workspace-service"
-			}))]
+			entries,
+			diagnostics: Array.from(diagnostics.values())
 		};
 	};
 	deleteRetained = async (dataId, confirmAppId) => {
@@ -6698,7 +6713,7 @@ async function replayNcpAgentSessionEvents(events, seedMessages = [], activeMess
 		const replayMessageId = readReplayMessageId(replayEvent);
 		if (replayMessageId) knownMessageIds.add(replayMessageId);
 		await stateManager.dispatch(replayEvent);
-		if (replayEvent.type === NcpEventType.MessageToolCallResult) toolResultsByCallId.set(replayEvent.payload.toolCallId, replayEvent.payload);
+		if (replayEvent.type === NcpEventType.MessageToolCallResult && replayEvent.payload.final !== false) toolResultsByCallId.set(replayEvent.payload.toolCallId, replayEvent.payload);
 	}
 	const snapshot = stateManager.getSnapshot();
 	return (snapshot.streamingMessage ? insertMessageByTimeline(snapshot.messages, snapshot.streamingMessage) : snapshot.messages).map(compactionRecovery.terminalize);
@@ -6727,7 +6742,7 @@ function readReplayEventOccurredAt(event) {
 function mergeReplayCompletedToolResults(message, toolResultsByCallId) {
 	let changed = false;
 	const parts = message.parts.map((part) => {
-		if (part.type !== "tool-invocation" || part.state === "result" || !part.toolCallId) return part;
+		if (part.type !== "tool-invocation" || !part.toolCallId) return part;
 		const result = toolResultsByCallId.get(part.toolCallId);
 		if (!result) return part;
 		changed = true;
@@ -6735,7 +6750,8 @@ function mergeReplayCompletedToolResults(message, toolResultsByCallId) {
 			...part,
 			state: "result",
 			result: result.content,
-			resultContentItems: result.contentItems
+			...result.contentItems ? { resultContentItems: result.contentItems } : {},
+			...result.execution ? { execution: mergeToolExecutionTiming(result.execution, part.execution) ?? result.execution } : {}
 		};
 	});
 	return changed ? {
@@ -6793,7 +6809,8 @@ function readStreamingMessageId(event) {
 		case NcpEventType.MessageReasoningDelta:
 		case NcpEventType.MessageReasoningEnd:
 		case NcpEventType.MessageToolCallStart:
-		case NcpEventType.MessageToolCallArgsDelta: return event.payload.messageId?.trim() || null;
+		case NcpEventType.MessageToolCallArgsDelta:
+		case NcpEventType.MessageToolExecutionStarted: return event.payload.messageId?.trim() || null;
 		default: return null;
 	}
 }
@@ -6976,7 +6993,7 @@ function applySessionOverrides(params) {
 //#endregion
 //#region src/utils/session-context-inheritance.utils.ts
 const CONTEXT_INHERITANCE_METADATA_KEY = "context_inheritance";
-const INHERITED_FROM_SESSION_METADATA_KEY = "inherited_from_session_id";
+const INHERITED_FROM_SESSION_METADATA_KEY$1 = "inherited_from_session_id";
 const INHERITED_FROM_MESSAGE_METADATA_KEY = "inherited_from_message_id";
 function hasToolCall(message, toolCallId) {
 	return message.parts.some((part) => part.type === "tool-invocation" && part.toolCallId === toolCallId);
@@ -6995,7 +7012,7 @@ function createInheritedContextMessage(params) {
 	const { childSessionId, index, sourceMessage, sourceSessionId } = params;
 	const message = structuredClone(sourceMessage);
 	const metadata = structuredClone(message.metadata ?? {});
-	metadata[INHERITED_FROM_SESSION_METADATA_KEY] = sourceSessionId;
+	metadata[INHERITED_FROM_SESSION_METADATA_KEY$1] = sourceSessionId;
 	metadata[INHERITED_FROM_MESSAGE_METADATA_KEY] = sourceMessage.id;
 	return {
 		...message,
@@ -7050,6 +7067,71 @@ function createSessionContextInheritance(params) {
 	};
 }
 //#endregion
+//#region src/managers/session-token-usage.manager.ts
+const INHERITED_FROM_SESSION_METADATA_KEY = "inherited_from_session_id";
+function sumNullableUsageMetric(executions, metric) {
+	const values = executions.flatMap((execution) => {
+		const value = execution.usage[metric];
+		return value === null ? [] : [value];
+	});
+	return values.length > 0 ? values.reduce((total, value) => total + value, 0) : null;
+}
+function buildTokenUsageTotals(executions) {
+	const inputTokens = sumNullableUsageMetric(executions, "inputTokens");
+	const cachedInputTokens = sumNullableUsageMetric(executions, "cachedInputTokens");
+	const hasCompleteCacheUsage = executions.length > 0 && executions.every((execution) => execution.usage.inputTokens !== null && execution.usage.cachedInputTokens !== null);
+	return {
+		inputTokens,
+		outputTokens: sumNullableUsageMetric(executions, "outputTokens"),
+		cachedInputTokens,
+		totalTokens: sumNullableUsageMetric(executions, "totalTokens"),
+		cacheHitRate: hasCompleteCacheUsage && inputTokens !== null && inputTokens > 0 && cachedInputTokens !== null && cachedInputTokens <= inputTokens ? cachedInputTokens / inputTokens : null
+	};
+}
+function resolveTokenUsageStatus(executions) {
+	if (executions.length === 0 || executions.every((execution) => execution.usage.status === "unavailable")) return "unavailable";
+	return executions.every((execution) => execution.usage.status === "reported") ? "reported" : "partial";
+}
+function buildModelTokenUsage(model, executions) {
+	return {
+		model,
+		...buildTokenUsageTotals(executions),
+		runCount: executions.length,
+		modelCallCount: sumNullableUsageMetric(executions, "modelCallCount"),
+		reportedModelCallCount: sumNullableUsageMetric(executions, "reportedModelCallCount"),
+		status: resolveTokenUsageStatus(executions)
+	};
+}
+function buildSessionTokenUsageSummary(params) {
+	const executionsByRunId = /* @__PURE__ */ new Map();
+	for (const message of params.messages) {
+		if (message.role !== "assistant" || typeof message.metadata?.[INHERITED_FROM_SESSION_METADATA_KEY] === "string") continue;
+		const execution = readNcpAiExecutionMetadata(message.metadata);
+		if (execution) executionsByRunId.set(execution.runId, execution);
+	}
+	const executions = [...executionsByRunId.values()];
+	const executionsByModel = /* @__PURE__ */ new Map();
+	for (const execution of executions) {
+		const modelExecutions = executionsByModel.get(execution.model) ?? [];
+		modelExecutions.push(execution);
+		executionsByModel.set(execution.model, modelExecutions);
+	}
+	const models = [...executionsByModel.entries()].map(([model, modelExecutions]) => buildModelTokenUsage(model, modelExecutions)).sort((left, right) => {
+		const leftTotal = left.totalTokens ?? -1;
+		const rightTotal = right.totalTokens ?? -1;
+		return rightTotal === leftTotal ? left.model.localeCompare(right.model) : rightTotal - leftTotal;
+	});
+	return {
+		sessionId: params.sessionId,
+		totals: buildTokenUsageTotals(executions),
+		models,
+		runCount: executions.length,
+		modelCallCount: sumNullableUsageMetric(executions, "modelCallCount"),
+		reportedModelCallCount: sumNullableUsageMetric(executions, "reportedModelCallCount"),
+		status: resolveTokenUsageStatus(executions)
+	};
+}
+//#endregion
 //#region src/services/session-event-ingestion.service.ts
 const SESSION_METADATA_PATCH_RUN_METADATA_KIND = "session_metadata_patch";
 function isDurableSessionEvent(event) {
@@ -7338,6 +7420,13 @@ var SessionManager = class {
 		}))?.messages ?? [];
 		return await this.options.journalStore.listSessionMessages(normalizedSessionId);
 	};
+	getSessionTokenUsage = async (sessionId) => {
+		const record = await this.getSessionRecord(sessionId);
+		return record ? buildSessionTokenUsageSummary({
+			sessionId: record.sessionId,
+			messages: record.messages
+		}) : null;
+	};
 	listSessionMessagePage = async (sessionId, options) => {
 		const { cursor, limit } = options;
 		const normalizedSessionId = normalizeSessionId(sessionId);
@@ -10115,7 +10204,8 @@ var ServiceAppRecordService = class {
 		const dirPath = join(serviceAppsPath, dirName);
 		try {
 			const manifest = await readServiceAppManifest(dirPath);
-			return this.fromManifest(dirPath, manifest, void 0, await this.materializeWorkspaceStorage(manifest.id));
+			if (manifest.id !== dirName) throw new Error(`service app manifest id must match directory name: ${dirName}`);
+			return this.fromManifest(dirPath, manifest, void 0, await this.inspectWorkspaceStorage(manifest.id));
 		} catch (error) {
 			if (this.isMissingFileError(error)) return null;
 			return this.failedWorkspaceRecord(dirName, dirPath, error);
@@ -10144,13 +10234,22 @@ var ServiceAppRecordService = class {
 		}))).filter((entry) => Boolean(entry));
 	};
 	materializeWorkspaceStorage = async (serviceId) => {
-		const instanceDirectory = join(this.params.getWorkspacePath(), ".nextclaw", "app-instances", serviceId, "default");
+		const instanceDirectory = this.getWorkspaceInstanceDirectory(serviceId);
 		return (await this.instanceStorageService.materialize({
 			appId: serviceId,
 			instanceId: "default",
 			instanceDirectory
 		})).storage;
 	};
+	inspectWorkspaceStorage = async (serviceId) => {
+		const instanceDirectory = this.getWorkspaceInstanceDirectory(serviceId);
+		if (!await this.pathExists(instanceDirectory)) return;
+		return (await this.instanceStorageService.inspect({
+			appId: serviceId,
+			instanceId: "default",
+			instanceDirectory
+		})).storage;
+	};
 	fromManifest = (dirPath, manifest, packageSource, storage) => {
 		const runtimeStatus = this.params.runtimeService.getStatus(manifest.id);
 		return {
@@ -10210,10 +10309,26 @@ var ServiceAppRecordService = class {
 		isolation: source.isolation
 	});
 	toTitle = (value) => basename(value).replace(/[-_]+/g, " ").trim() || value;
+	getWorkspaceInstanceDirectory = (serviceId) => join(this.params.getWorkspacePath(), ".nextclaw", "app-instances", serviceId, "default");
+	pathExists = async (targetPath) => {
+		try {
+			await access(targetPath);
+			return true;
+		} catch (error) {
+			if (this.isMissingFileError(error)) return false;
+			throw error;
+		}
+	};
 	isMissingFileError = (error) => typeof error === "object" && error !== null && error.code === "ENOENT";
 };
 //#endregion
 //#region src/services/service-app-removal.service.ts
+const TRANSACTION_ID = "[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}";
+const CURRENT_DELETION_PATTERN = new RegExp(`^\\.deleting-(?<appId>[a-z0-9]+(?:-[a-z0-9]+)*)-(?<transactionId>${TRANSACTION_ID})$`);
+const LEGACY_DELETION_PATTERN = new RegExp(`^(?<appId>[a-z0-9]+(?:-[a-z0-9]+)*)\\.deleting-(?<transactionId>${TRANSACTION_ID})$`);
+function isServiceAppDeletionTombstone(directoryName) {
+	return Boolean(parseServiceAppDeletionTombstone(directoryName));
+}
 var ServiceAppRemovalCleanupError = class extends Error {
 	constructor(cause) {
 		super(`临时目录清理失败：${cause instanceof Error ? cause.message : String(cause)}`);
@@ -10223,6 +10338,7 @@ var ServiceAppRemovalCleanupError = class extends Error {
 };
 var ServiceAppRemovalService = class {
 	fileLockService = new FileLockService();
+	listCanonicalDirectoryNames = async (serviceAppsPath) => (await this.listDirectories(serviceAppsPath)).filter((directoryName) => !directoryName.startsWith(".") && !isServiceAppDeletionTombstone(directoryName));
 	remove = async (params) => await this.fileLockService.withLock(params.lockPath, async () => {
 		const record = await params.loadRecord();
 		await this.removeLocked({
@@ -10231,14 +10347,39 @@ var ServiceAppRemovalService = class {
 		});
 		return record;
 	});
+	reconcile = async (params) => {
+		const { grantStore, lockPathForAppId, serviceAppsPath } = params;
+		const diagnostics = [];
+		for (const directoryName of await this.listDirectories(serviceAppsPath)) {
+			const appId = parseServiceAppDeletionTombstone(directoryName);
+			if (!appId) continue;
+			const stagedPath = join(serviceAppsPath, directoryName);
+			const canonicalPath = join(serviceAppsPath, appId);
+			try {
+				await this.fileLockService.withLock(lockPathForAppId(appId), async () => {
+					const manifest = await readServiceAppManifest(stagedPath);
+					if (manifest.id !== appId) throw new Error(`Service App 删除墓碑 identity 不匹配：${manifest.id}`);
+					if (!await this.pathExists(canonicalPath)) await grantStore.revokeActionsByPrefix(`${appId}.`);
+					await rm(stagedPath, { recursive: true });
+				});
+			} catch (error) {
+				diagnostics.push({
+					appId,
+					stagedPath,
+					message: error instanceof Error ? error.message : String(error)
+				});
+			}
+		}
+		return diagnostics.sort((left, right) => left.stagedPath.localeCompare(right.stagedPath));
+	};
 	removeLocked = async (params) => {
 		const { grantStore, purgeData, record, stopRuntime } = params;
 		const grants = (await grantStore.list()).filter((grant) => grant.actionId.startsWith(`${record.id}.`));
 		const stagedPaths = [];
 		try {
 			await stopRuntime(record);
-			await this.stagePath(record.dirPath, stagedPaths);
-			if (purgeData && record.storage) await this.stagePath(record.storage.instanceDirectory, stagedPaths);
+			await this.stageSourcePath(record.dirPath, stagedPaths);
+			if (purgeData && record.storage) await this.stageInstancePath(record.storage.instanceDirectory, stagedPaths);
 			await grantStore.revokeActionsByPrefix(`${record.id}.`);
 		} catch (error) {
 			const recoveryErrors = [...await this.restoreStagedPaths(stagedPaths), ...await this.restoreGrants(grantStore, grants)];
@@ -10251,7 +10392,15 @@ var ServiceAppRemovalService = class {
 			throw new ServiceAppRemovalCleanupError(error);
 		}
 	};
-	stagePath = async (originalPath, stagedPaths) => {
+	stageSourcePath = async (originalPath, stagedPaths) => {
+		const stagedPath = join(dirname(originalPath), `.deleting-${basename(originalPath)}-${randomUUID()}`);
+		await rename(originalPath, stagedPath);
+		stagedPaths.push({
+			originalPath,
+			stagedPath
+		});
+	};
+	stageInstancePath = async (originalPath, stagedPaths) => {
 		const stagedPath = `${originalPath}.deleting-${randomUUID()}`;
 		await rename(originalPath, stagedPath);
 		stagedPaths.push({
@@ -10259,6 +10408,24 @@ var ServiceAppRemovalService = class {
 			stagedPath
 		});
 	};
+	listDirectories = async (directory) => {
+		try {
+			return (await readdir(directory, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+		} catch (error) {
+			if (this.isMissingFileError(error)) return [];
+			throw error;
+		}
+	};
+	pathExists = async (targetPath) => {
+		try {
+			await access(targetPath);
+			return true;
+		} catch (error) {
+			if (this.isMissingFileError(error)) return false;
+			throw error;
+		}
+	};
+	isMissingFileError = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 	restoreStagedPaths = async (stagedPaths) => {
 		const errors = [];
 		for (const entry of [...stagedPaths].reverse()) try {
@@ -10278,6 +10445,9 @@ var ServiceAppRemovalService = class {
 		return errors;
 	};
 };
+function parseServiceAppDeletionTombstone(directoryName) {
+	return CURRENT_DELETION_PATTERN.exec(directoryName)?.groups?.appId ?? LEGACY_DELETION_PATTERN.exec(directoryName)?.groups?.appId;
+}
 //#endregion
 //#region src/stores/service-action-grant.store.ts
 const EMPTY_GRANTS = {
@@ -10425,13 +10595,12 @@ var ServiceAppError = class extends Error {
 		this.name = "ServiceAppError";
 	}
 };
-function isServiceAppError(error) {
-	return error instanceof ServiceAppError;
-}
+const isServiceAppError = (error) => error instanceof ServiceAppError;
 var ServiceAppManager = class {
 	removalService = new ServiceAppRemovalService();
 	runtimeService;
 	recordService;
+	reconciliationDiagnostics = [];
 	constructor(params) {
 		this.params = params;
 		this.runtimeService = params.runtimeService ?? new McpServiceAppRuntimeService({ getConfig: () => params.configManager.config });
@@ -10440,6 +10609,13 @@ var ServiceAppManager = class {
 			runtimeService: this.runtimeService
 		});
 	}
+	start = async () => {
+		this.reconciliationDiagnostics = await this.removalService.reconcile({
+			grantStore: this.createGrantStore(),
+			lockPathForAppId: (appId) => this.getServiceAppLockPath(this.getWorkspacePath(), appId),
+			serviceAppsPath: this.getServiceAppsPath(this.getWorkspacePath())
+		});
+	};
 	listServiceApps = async () => {
 		const workspacePath = this.getWorkspacePath();
 		const serviceAppsPath = this.getServiceAppsPath(workspacePath);
@@ -10450,6 +10626,7 @@ var ServiceAppManager = class {
 		return {
 			workspacePath,
 			serviceAppsPath,
+			diagnostics: this.reconciliationDiagnostics,
 			entries: [...workspaceEntries, ...packageEntries].filter((entry) => Boolean(entry)).sort((left, right) => left.title.localeCompare(right.title))
 		};
 	};
@@ -10462,7 +10639,7 @@ var ServiceAppManager = class {
 		return await Promise.all(actions.map(async (action) => await this.withGrantState(action, params)));
 	};
 	discoverServiceAppActions = async (appId) => {
-		const { manifest, record } = await this.requireServiceApp(appId);
+		const { manifest, record } = await this.requireServiceApp(appId, true);
 		return mergeServiceAppRuntimeActions({
 			record,
 			manifest,
@@ -10475,7 +10652,7 @@ var ServiceAppManager = class {
 	invokeServiceAction = async (actionId, request) => {
 		this.assertCaller(request.caller);
 		this.assertDeclaredAction(actionId, request.declaredActions);
-		const { manifest, record } = await this.requireServiceAppForAction(actionId);
+		const { manifest, record } = await this.requireServiceAppForAction(actionId, true);
 		const actionName = getServiceActionName(actionId, record.id);
 		if (!Object.hasOwn(manifest.actions, actionName)) throw new ServiceAppError("SERVICE_APP_ACTION_NOT_FOUND", "service action not found");
 		const declaredRisk = manifest.actions[actionName]?.risk ?? "dangerous";
@@ -10535,12 +10712,11 @@ var ServiceAppManager = class {
 		try {
 			record = await this.removalService.remove({
 				grantStore: this.createGrantStore(),
-				lockPath: join(workspacePath, ".nextclaw", "locks", "service-apps", `${appId}.lock`),
+				lockPath: this.getServiceAppLockPath(workspacePath, appId),
 				purgeData,
 				loadRecord: async () => {
 					const { record } = await this.requireServiceApp(appId);
 					if (record.sourceKind === "package") throw new ServiceAppError("SERVICE_APP_MANAGED_SOURCE", `package service must be managed through Apps: ${record.packageId}`);
-					if (purgeData && !record.storage) throw new ServiceAppError("SERVICE_APP_READ_FAILED", `Service App ${appId} 缺少受管数据目录，已停止删除。`);
 					return record;
 				},
 				stopRuntime: async (loaded) => await this.runtimeService.restart(loaded.id)
@@ -10624,12 +10800,12 @@ var ServiceAppManager = class {
 		if (!action) throw new ServiceAppError("SERVICE_APP_ACTION_NOT_FOUND", "service action not found");
 		return action;
 	};
-	requireServiceAppForAction = async (actionId) => {
+	requireServiceAppForAction = async (actionId, materializeStorage = false) => {
 		const appId = actionId.split(".")[0]?.trim();
 		if (!appId) throw new ServiceAppError("SERVICE_APP_INVALID_ACTION", "service action id is invalid");
-		return await this.requireServiceApp(appId);
+		return await this.requireServiceApp(appId, materializeStorage);
 	};
-	requireServiceApp = async (appId) => {
+	requireServiceApp = async (appId, materializeStorage = false) => {
 		let dirPath = join(this.getServiceAppsPath(this.getWorkspacePath()), appId);
 		let packageSource;
 		try {
@@ -10644,9 +10820,10 @@ var ServiceAppManager = class {
 			if (!(await stat(dirPath)).isDirectory()) throw new ServiceAppError("SERVICE_APP_NOT_FOUND", "service app not found");
 			const manifest = await readServiceAppManifest(dirPath);
 			if (manifest.id !== appId) throw new ServiceAppError("SERVICE_APP_INVALID_MANIFEST", "service app manifest id must match directory name");
+			const storage = packageSource?.storage ?? (materializeStorage ? await this.recordService.materializeWorkspaceStorage(manifest.id) : await this.recordService.inspectWorkspaceStorage(manifest.id));
 			return {
 				manifest,
-				record: this.recordService.fromManifest(dirPath, manifest, packageSource, packageSource?.storage ?? await this.recordService.materializeWorkspaceStorage(manifest.id))
+				record: this.recordService.fromManifest(dirPath, manifest, packageSource, storage)
 			};
 		} catch (error) {
 			if (isServiceAppError(error)) throw error;
@@ -10664,7 +10841,7 @@ var ServiceAppManager = class {
 				const manifest = await readServiceAppManifest(dirPath);
 				return {
 					manifest,
-					record: this.recordService.fromManifest(dirPath, manifest, void 0, await this.recordService.materializeWorkspaceStorage(manifest.id))
+					record: this.recordService.fromManifest(dirPath, manifest, void 0, await this.recordService.inspectWorkspaceStorage(manifest.id))
 				};
 			} catch {
 				return null;
@@ -10692,13 +10869,13 @@ var ServiceAppManager = class {
 	normalizeActionIds = (actionIds) => Array.from(new Set(actionIds.map((actionId) => actionId.trim()).filter((actionId) => actionId.length > 0)));
 	getWorkspacePath = () => getWorkspacePathFromConfig(this.params.configManager.config);
 	getServiceAppsPath = (workspacePath) => join(workspacePath, DEFAULT_SERVICE_APPS_DIR);
+	getServiceAppLockPath = (workspacePath, appId) => join(workspacePath, ".nextclaw", "locks", "service-apps", `${appId}.lock`);
 	createGrantStore = () => new ServiceActionGrantStore(join(this.getServiceAppsPath(this.getWorkspacePath()), SERVICE_ACTION_GRANTS_FILE_NAME));
 	listPackageComponentSources = async () => await this.params.listPackageComponentSources?.() ?? [];
 	listServiceAppDirNames = async (serviceAppsPath) => {
 		try {
-			return (await readdir(serviceAppsPath, { withFileTypes: true })).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name);
+			return await this.removalService.listCanonicalDirectoryNames(serviceAppsPath);
 		} catch (error) {
-			if (this.isMissingFileError(error)) return [];
 			throw new ServiceAppError("SERVICE_APP_READ_FAILED", error instanceof Error ? error.message : String(error));
 		}
 	};
@@ -15970,6 +16147,9 @@ var NextclawKernel = class {
 	};
 	getGatewayController = () => this.gatewayController;
 	start = async () => {
+		await this.appPackageManager.start();
+		await this.appDataManager.start();
+		await this.serviceAppManager.start();
 		this.sessionSearch.start();
 		this.mcpManager.start();
 		this.providerModelCatalog.start();