@nextclaw/kernel 0.15.0-beta.0 → 0.15.0

package/dist/index.js

@@ -11,7 +11,7 @@ import { DefaultNcpAgentConversationStateManager, insertMessageByTimeline, merge
 import { accessSync, appendFileSync, chmodSync, constants, createReadStream, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import path, { basename, delimiter, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
 import { access, appendFile, chmod, lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
-import { AppHomeService, AppInstallationService, AppInstanceInventoryService, AppInstanceStorageService, AppManifestService, AppPlatformTargetService, AppRegistryService, AppServiceLaunchService, FileLockService, isAppComponentManifestBundle } from "@nextclaw/app-runtime";
+import { AppGrantService, AppHomeService, AppInstallationService, AppInstanceInventoryService, AppInstanceStorageService, AppManifestService, AppPlatformTargetService, AppRegistryService, AppServiceLaunchService, FileLockService, isAppComponentManifestBundle } from "@nextclaw/app-runtime";
 import { execFileSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { BUILTIN_PROVIDER_PLUGINS } from "@nextclaw/runtime";
@@ -3664,7 +3664,11 @@ var AppPackageReadinessManager = class {
 			isolation: manifestBundle.manifest.main.kind === "wasi-http-component" ? "host-mediated" : "sandboxed",
 			permissions: manifestBundle.manifest.permissions ?? {}
 		};
-		const [dependencies, secrets] = await Promise.all([this.params.dependencyCoordinator.inspectTarget(this.params.dependencyCoordinator.targetForInfo(info, selectedVersion), providers), this.inspectSecretsForInfo(info, true, selectedVersion)]);
+		const [dependencies, secrets, documentAccess] = await Promise.all([
+			this.params.dependencyCoordinator.inspectTarget(this.params.dependencyCoordinator.targetForInfo(info, selectedVersion), providers),
+			this.inspectSecretsForInfo(info, true, selectedVersion),
+			this.params.grantService.summarize(info.appId).then((state) => state.documentAccess)
+		]);
 		return {
 			id: info.appId,
 			name: info.name,
@@ -3701,7 +3705,8 @@ var AppPackageReadinessManager = class {
 			isolation: security.isolation,
 			readiness: this.combineReadiness(dependencies.readiness, secrets.readiness),
 			secrets,
-			dependencies
+			dependencies,
+			documentAccess
 		};
 	};
 	inspectSecrets = async (info, verify, selectedVersion = info.activeVersion) => {
@@ -4537,6 +4542,73 @@ var AppPackageDependencyCoordinator = class {
 	};
 };
 //#endregion
+//#region src/services/app-package-document-access.service.ts
+var AppPackageDocumentAccessService = class {
+	constructor(params) {
+		this.params = params;
+	}
+	inspect = async (appId) => await this.params.installationService.withAppOperation(appId, async () => {
+		try {
+			return await this.params.grantService.summarize(appId);
+		} catch (error) {
+			throw this.toError(error);
+		}
+	});
+	assert = async (appId, scopeId, requestedMode) => {
+		const scope = (await this.inspect(appId)).documentAccess.find((entry) => entry.id === scopeId);
+		if (!scope) throw new AppPackageError("DOCUMENT_SCOPE_NOT_DECLARED", `App ${appId} does not declare document scope ${scopeId}.`);
+		if (!scope.granted) throw new AppPackageError("DOCUMENT_SCOPE_NOT_GRANTED", `App ${appId} requires document scope ${scopeId}. Grant it and retry the action.`);
+		if (scope.status === "unavailable") throw new AppPackageError("DOCUMENT_SCOPE_UNAVAILABLE", `App ${appId} document scope ${scopeId} is unavailable. Replace or revoke it.`);
+		if (requestedMode === "read-write" && scope.effectiveMode !== "read-write") throw new AppPackageError("DOCUMENT_SCOPE_MODE_INSUFFICIENT", `App ${appId} document scope ${scopeId} needs read-write access.`);
+	};
+	grant = async (appId, input) => await this.mutate(appId, input.scopeId, async () => await this.params.grantService.grantDocumentScope({
+		appId,
+		...input
+	}));
+	revoke = async (appId, scopeId) => await this.mutate(appId, scopeId, async () => {
+		if (!(await this.params.grantService.summarize(appId)).documentAccess.some((scope) => scope.id === scopeId)) throw new AppPackageError("DOCUMENT_SCOPE_NOT_DECLARED", `App ${appId} does not declare document scope ${scopeId}.`);
+		return await this.params.grantService.revokeDocumentScope({
+			appId,
+			scopeId
+		});
+	});
+	mutate = async (appId, scopeId, mutation) => await this.params.installationService.withAppOperation(appId, async () => {
+		const app = await this.params.getPackage(appId);
+		const previousGrant = (await this.params.registryService.getApp(appId))?.grants[scopeId];
+		const sources = this.toComponentSources(app);
+		const runtimeHooks = this.params.getRuntimeHooks();
+		const rollbackRuntime = app.enabled ? await runtimeHooks.prepareCapabilityChange(sources) : async () => void 0;
+		try {
+			const result = await mutation();
+			if (app.enabled) await runtimeHooks.afterCapabilityChange(sources);
+			return result;
+		} catch (error) {
+			const recoveryErrors = [];
+			try {
+				await this.params.registryService.restoreDocumentGrant(appId, scopeId, previousGrant);
+			} catch (recoveryError) {
+				recoveryErrors.push(recoveryError);
+			}
+			try {
+				await rollbackRuntime();
+			} catch (recoveryError) {
+				recoveryErrors.push(recoveryError);
+			}
+			if (recoveryErrors.length > 0) throw new AggregateError([error, ...recoveryErrors], `App ${appId} document scope ${scopeId} mutation failed and recovery was incomplete.`);
+			throw this.toError(error);
+		}
+	});
+	toComponentSources = (app) => app.components.map((component) => ({ ...component }));
+	toError = (error) => {
+		if (error instanceof AppPackageError) return error;
+		const message = error instanceof Error ? error.message : String(error);
+		if (message.includes("未声明 documentAccess scope")) return new AppPackageError("DOCUMENT_SCOPE_NOT_DECLARED", message);
+		if (message.includes("只声明了 read")) return new AppPackageError("DOCUMENT_SCOPE_MODE_INSUFFICIENT", message);
+		if (message.includes("不是可用目录")) return new AppPackageError("DOCUMENT_SCOPE_UNAVAILABLE", message);
+		return new AppPackageError("DOCUMENT_SCOPE_MUTATION_FAILED", message);
+	};
+};
+//#endregion
 //#region src/services/app-package-host-target.service.ts
 var AppPackageHostTargetService = class {
 	platformTargetService = new AppPlatformTargetService();
@@ -4607,6 +4679,8 @@ const EMPTY_APP_PACKAGE_RUNTIME_HOOKS = {
 	assertCanActivate: async () => void 0,
 	afterActivate: async () => void 0,
 	beforeDeactivate: async () => void 0,
+	prepareCapabilityChange: async () => async () => void 0,
+	afterCapabilityChange: async () => void 0,
 	beforeUninstall: async () => void 0
 };
 var AppPackageRuntimeActivationService = class {
@@ -4637,6 +4711,8 @@ var AppPackageManager = class {
 	dependencyCoordinator;
 	runtimeActivationService = new AppPackageRuntimeActivationService();
 	registryService;
+	grantService;
+	documentAccessService;
 	readinessManager;
 	runtimeHooks = EMPTY_APP_PACKAGE_RUNTIME_HOOKS;
 	builtInBootstrapPromise;
@@ -4646,6 +4722,14 @@ var AppPackageManager = class {
 		this.appHomeService = new AppHomeService(params.appHomeDirectory);
 		this.installationService = new AppInstallationService(this.appHomeService);
 		this.registryService = new AppRegistryService(this.appHomeService);
+		this.grantService = new AppGrantService(this.registryService, this.manifestService);
+		this.documentAccessService = new AppPackageDocumentAccessService({
+			grantService: this.grantService,
+			installationService: this.installationService,
+			registryService: this.registryService,
+			getPackage: this.getPackage,
+			getRuntimeHooks: () => this.runtimeHooks
+		});
 		this.dependencyCoordinator = new AppPackageDependencyCoordinator({
 			installationService: this.installationService,
 			registryService: this.registryService,
@@ -4658,6 +4742,7 @@ var AppPackageManager = class {
 			presentationService: this.presentationService,
 			dependencyCoordinator: this.dependencyCoordinator,
 			registryService: this.registryService,
+			grantService: this.grantService,
 			productVersion: params.productVersion,
 			getSecretConfig: params.getSecretConfig,
 			secretConfigPath: params.secretConfigPath,
@@ -4718,6 +4803,12 @@ var AppPackageManager = class {
 		await this.registryService.unbindSecret(appId, slotId);
 		return await this.inspectSecrets(appId);
 	});
+	inspectDocumentAccess = async (appId) => await this.documentAccessService.inspect(appId);
+	assertDocumentAccess = async (appId, scopeId, requestedMode) => {
+		await this.documentAccessService.assert(appId, scopeId, requestedMode);
+	};
+	grantDocumentAccess = async (appId, input) => await this.documentAccessService.grant(appId, input);
+	revokeDocumentAccess = async (appId, scopeId) => await this.documentAccessService.revoke(appId, scopeId);
 	listActiveComponentSources = async () => (await this.listActiveComponentSourcesWithDiagnostics()).sources;
 	listActiveComponentSourcesWithDiagnostics = async () => await this.dependencyCoordinator.listActiveComponentSourcesWithDiagnostics();
 	listOperations = async () => await this.operationManager.list();
@@ -6590,6 +6681,9 @@ function isRecord$18(value) {
 //#region src/utils/service-app-error.utils.ts
 const SERVICE_APP_ERROR_CODES = new Set([
 	"AUTHORIZATION_REQUIRED",
+	"DOCUMENT_SCOPE_NOT_GRANTED",
+	"DOCUMENT_SCOPE_MODE_INSUFFICIENT",
+	"DOCUMENT_SCOPE_UNAVAILABLE",
 	"SERVICE_APP_ACTION_NOT_DECLARED",
 	"SERVICE_APP_ACTION_NOT_FOUND",
 	"SERVICE_APP_INVALID_ACTION",
@@ -7650,23 +7744,23 @@ var DesktopNodeReplService = class {
 			});
 			case "setValue": return await this.sessionState.setValue(caller, {
 				target,
-				stateId: requiredString$1(args.stateId, "stateId"),
+				stateId: requiredString$2(args.stateId, "stateId"),
 				elementIndex: readElementIndex(args.element),
 				value: requiredValue$1(args.value ?? args.text, "value")
 			});
 			case "click": return await this.sessionState.click(caller, {
 				target,
-				stateId: requiredString$1(args.stateId, "stateId"),
+				stateId: requiredString$2(args.stateId, "stateId"),
 				...args.coordinate === void 0 ? { elementIndex: readElementIndex(args.element) } : { coordinate: readCoordinate(args.coordinate) }
 			});
 			case "typeText": return await this.sessionState.typeText(caller, {
 				target,
-				stateId: requiredString$1(args.stateId, "stateId"),
+				stateId: requiredString$2(args.stateId, "stateId"),
 				text: requiredText(args.text, "text")
 			});
 			case "pressKey": return await this.sessionState.pressKey(caller, {
 				target,
-				stateId: requiredString$1(args.stateId, "stateId"),
+				stateId: requiredString$2(args.stateId, "stateId"),
 				key: readKeyboardKey(args.key),
 				...args.modifiers === void 0 ? {} : { modifiers: readKeyboardModifiers(args.modifiers) }
 			});
@@ -7713,7 +7807,7 @@ function pickCaller(input) {
 	};
 }
 function readTarget(value) {
-	return { applicationId: requiredString$1(asRecord$1(value).applicationId, "target.applicationId") };
+	return { applicationId: requiredString$2(asRecord$1(value).applicationId, "target.applicationId") };
 }
 function readElementIndex(value) {
 	const index = asRecord$1(value).index;
@@ -7737,7 +7831,7 @@ function isFiniteNumber$1(value) {
 function asRecord$1(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function requiredString$1(value, field) {
+function requiredString$2(value, field) {
 	if (typeof value !== "string" || !value.trim()) throw replError("invalid_tool_arguments", `${field} must be a non-empty string.`);
 	return value.trim();
 }
@@ -7769,7 +7863,7 @@ const SUPPORTED_KEY_MODIFIERS = new Set([
 	"shift"
 ]);
 function readKeyboardKey(value) {
-	const key = requiredString$1(value, "key");
+	const key = requiredString$2(value, "key");
 	if (!SUPPORTED_KEYS.has(key)) throw replError("invalid_tool_arguments", "key must be a supported named key or a lowercase letter/digit.");
 	return key;
 }
@@ -13644,16 +13738,15 @@ function applySessionRuntimePatch(metadata, patch) {
 function applySessionSettingsMetadataPatch(currentMetadata, patch) {
 	return applySessionRuntimePatch(applySessionPreferencePatch(structuredClone(currentMetadata), patch), patch);
 }
-async function applySessionProjectMetadataPatch(metadata, patch, normalizeProjectRoot) {
+async function applySessionProjectMetadataPatch(metadata, patch, normalizeProjectContext) {
 	if (!Object.prototype.hasOwnProperty.call(patch, "projectRoot")) return metadata;
-	const projectRoot = await normalizeProjectRoot(patch.projectRoot);
-	const { projectRoot: _legacyProjectRoot, ...nextMetadata } = metadata;
-	if (projectRoot) return {
+	const project = await normalizeProjectContext(patch.projectRoot);
+	const { projectRoot: _legacyProjectRoot, projectId: _legacyProjectId, project_root: _projectRoot, project_id: _projectId, ...nextMetadata } = metadata;
+	return project ? {
 		...nextMetadata,
-		project_root: projectRoot
-	};
-	const { project_root: _projectRoot, ...metadataWithoutProjectRoot } = nextMetadata;
-	return metadataWithoutProjectRoot;
+		project_id: project.projectId,
+		project_root: project.rootPath
+	} : nextMetadata;
 }
 function publishSessionMetadataChanged(eventBus, sessionKey, metadata, mode) {
 	eventBus.emit(eventKeys$1.sessionMetadataChanged, {
@@ -13715,6 +13808,9 @@ function readThinkingEffort(metadata) {
 function readProjectRoot(metadata) {
 	return readOptionalMetadataString(metadata?.project_root) ?? readOptionalMetadataString(metadata?.projectRoot);
 }
+function readProjectId(metadata) {
+	return readOptionalMetadataString(metadata?.project_id) ?? readOptionalMetadataString(metadata?.projectId);
+}
 function readAgentRuntimeId(metadata) {
 	return readOptionalMetadataString(metadata?.agentRuntimeId) ?? readOptionalMetadataString(metadata?.runtime) ?? readOptionalMetadataString(metadata?.session_type);
 }
@@ -13731,6 +13827,7 @@ function cloneInheritedMetadata(sourceMetadata) {
 		"preferred_model",
 		"preferred_thinking",
 		"project_root",
+		"project_id",
 		"codex_runtime_backend",
 		"reasoningNormalizationMode",
 		"reasoning_normalization_mode"
@@ -13784,6 +13881,9 @@ function resolveKernelPreferenceStorePath(options) {
 function resolveKernelProjectStorePath(options) {
 	return resolveKernelDataPath(options, "projects", "projects.json");
 }
+function resolveKernelProjectWorkStorePath(options) {
+	return resolveKernelDataPath(options, "projects", "work-items.db");
+}
 function resolveKernelInboxDeliveryStorePath(options) {
 	return resolveKernelDataPath(options, "inbox", "deliveries.json");
 }
@@ -15105,10 +15205,14 @@ var PortableServiceCapabilityResolverService = class {
 		if (!record || app.packageVersion && record.activeVersion !== app.packageVersion) return [];
 		const resolved = [];
 		for (const scope of scopes) {
-			const grantedPath = record.grants[scope.id];
-			if (grantedPath) resolved.push({
-				scope,
-				hostPath: await this.requireCanonicalDirectory(grantedPath, `${app.id}:${scope.id}`)
+			const grant = record.grants[scope.id];
+			if (!grant || grant.mode === "read-write" && scope.mode !== "read-write") continue;
+			resolved.push({
+				scope: {
+					...scope,
+					mode: grant.mode
+				},
+				hostPath: await this.requireCanonicalDirectory(grant.path, `${app.id}:${scope.id}`)
 			});
 		}
 		return resolved;
@@ -17340,6 +17444,7 @@ function projectCapabilityProviders(entries) {
 //#endregion
 //#region src/managers/service-app.manager.ts
 const SERVICE_APP_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const DOCUMENT_GUEST_PATH_PATTERN = /^\/documents\/([^/]+)(?:\/|$)/;
 var ServiceAppManager = class {
 	removalService = new ServiceAppRemovalService();
 	runtimeService;
@@ -17488,6 +17593,7 @@ var ServiceAppManager = class {
 		const action = listServiceAppManifestActions(record, manifest).find((entry) => entry.id === actionId);
 		if (!action) throw new ServiceAppError("SERVICE_APP_ACTION_NOT_FOUND", "service action not found");
 		if (!await this.actionGrants.isGranted(request.caller, action)) throw new ServiceAppError("AUTHORIZATION_REQUIRED", `This panel app needs permission to call ${actionId}.`);
+		await this.assertDocumentInputAccess(record, action.risk, request.input ?? {});
 		return await this.jobManager.invoke({
 			actionId,
 			actionName,
@@ -17504,6 +17610,8 @@ var ServiceAppManager = class {
 	*/
 	invokeInstalledServiceAction = async (appId, actionName, input = {}) => {
 		const { manifest, record } = await this.requireInstalledServiceApp(appId, actionName);
+		const action = listServiceAppManifestActions(record, manifest).find((entry) => entry.name === actionName);
+		await this.assertDocumentInputAccess(record, action?.risk ?? "dangerous", input);
 		return await this.jobManager.invoke({
 			actionId: buildServiceActionId(record.id, actionName),
 			actionName,
@@ -17514,6 +17622,24 @@ var ServiceAppManager = class {
 			entrySurface: "installed-app-cli"
 		});
 	};
+	assertDocumentInputAccess = async (record, risk, input) => {
+		const match = (typeof input.path === "string" ? input.path : void 0)?.match(DOCUMENT_GUEST_PATH_PATTERN);
+		if (!match || !record.packageId || !this.params.assertDocumentAccess) return;
+		const scopeId = decodeURIComponent(match[1]);
+		const requestedMode = risk === "read" ? "read" : "read-write";
+		try {
+			await this.params.assertDocumentAccess(record.packageId, scopeId, requestedMode);
+		} catch (error) {
+			const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "DOCUMENT_SCOPE_NOT_GRANTED";
+			if (code === "DOCUMENT_SCOPE_NOT_GRANTED" || code === "DOCUMENT_SCOPE_MODE_INSUFFICIENT" || code === "DOCUMENT_SCOPE_UNAVAILABLE") throw new ServiceAppError(code, error instanceof Error ? error.message : code, {
+				appId: record.packageId,
+				scopeId,
+				requestedMode,
+				recoveryActions: code === "DOCUMENT_SCOPE_UNAVAILABLE" ? ["replace", "revoke"] : code === "DOCUMENT_SCOPE_MODE_INSUFFICIENT" ? ["upgrade"] : ["grant"]
+			});
+			throw error;
+		}
+	};
 	listVerificationRecords = async (filters = {}) => await this.jobManager.listVerificationRecords(filters);
 	exportVerificationRecords = async (filters = {}) => await this.jobManager.exportVerificationRecords(filters);
 	listServiceAppJobs = async (appId, params = {}) => await this.jobManager.list(appId, params.caller);
@@ -18870,7 +18996,7 @@ var SessionSettingsService = class {
 			existing = await this.options.getSessionRecord(sessionId);
 		}
 		if (!existing) return null;
-		const metadata = await applySessionProjectMetadataPatch(applySessionSettingsMetadataPatch(existing.metadata ?? {}, patch), patch, this.options.normalizeProjectRoot);
+		const metadata = await applySessionProjectMetadataPatch(applySessionSettingsMetadataPatch(existing.metadata ?? {}, patch), patch, this.options.normalizeProjectContext);
 		return await this.options.setSessionMetadata(sessionId, metadata) ? await this.options.getSession(sessionId) : null;
 	};
 };
@@ -18973,7 +19099,7 @@ var SessionManager = class {
 			createSession: this.createSession,
 			getSession: this.getSession,
 			getSessionRecord: this.getSessionRecord,
-			normalizeProjectRoot: options.projectManager.normalizeSessionProjectRoot,
+			normalizeProjectContext: options.projectManager.normalizeSessionProjectContext,
 			setSessionMetadata: this.setSessionMetadata
 		});
 	}
@@ -19005,14 +19131,9 @@ var SessionManager = class {
 			title
 		});
 		const now = (/* @__PURE__ */ new Date()).toISOString();
-		const nextMetadata = mergeMetadataOverrides(metadata, metadataOverrides);
+		let nextMetadata = mergeMetadataOverrides(metadata, metadataOverrides);
 		const requestedProjectRoot = projectRoot !== void 0 ? projectRoot : readProjectRoot(nextMetadata);
-		if (requestedProjectRoot !== void 0) {
-			const normalizedProjectRoot = await this.options.projectManager.normalizeSessionProjectRoot(requestedProjectRoot);
-			delete nextMetadata.projectRoot;
-			if (normalizedProjectRoot) nextMetadata.project_root = normalizedProjectRoot;
-			else delete nextMetadata.project_root;
-		}
+		if (requestedProjectRoot !== void 0) nextMetadata = await applySessionProjectMetadataPatch(nextMetadata, { projectRoot: requestedProjectRoot }, this.options.projectManager.normalizeSessionProjectContext);
 		const agentId = readOptionalString$10(requestedAgentId) ?? readOptionalString$10(sourceRecord?.agentId) ?? BUILTIN_MAIN_AGENT_ID;
 		const sessionId = readOptionalString$10(requestedSessionId) ?? buildSessionId();
 		const inheritedContext = createSessionContextInheritance({
@@ -19197,6 +19318,7 @@ var SessionManager = class {
 			metadata: structuredClone(created.metadata ?? {}),
 			model: model ?? readOptionalMetadataString(created.metadata?.model) ?? readOptionalMetadataString(created.metadata?.preferred_model),
 			projectRoot: readProjectRoot(created.metadata),
+			projectId: readProjectId(created.metadata),
 			workingDir: this.workingDirResolver.resolve({
 				agentId: created.agentId,
 				metadata: created.metadata
@@ -19218,6 +19340,7 @@ var SessionManager = class {
 			metadata: structuredClone(metadata),
 			model: readOptionalMetadataString(metadata.model) ?? readOptionalMetadataString(metadata.preferred_model),
 			projectRoot: readProjectRoot(metadata),
+			projectId: readProjectId(metadata),
 			workingDir: this.workingDirResolver.resolve({
 				agentId: summary.agentId,
 				metadata
@@ -20375,14 +20498,20 @@ var ProjectManager = class {
 		});
 	};
 	normalizeSessionProjectRoot = async (value) => {
+		return (await this.normalizeSessionProjectContext(value))?.rootPath ?? null;
+	};
+	normalizeSessionProjectContext = async (value) => {
 		if (value == null || typeof value === "string" && !value.trim()) return null;
 		const rootPath = await this.resolveExistingProjectRoot(value);
 		if (!rootPath) return null;
-		await this.upsertProject({
+		const project = await this.upsertProject({
 			name: basename(rootPath),
 			rootPath
 		});
-		return rootPath;
+		return {
+			projectId: project.id,
+			rootPath: project.rootPath
+		};
 	};
 	resolveExistingProjectRoot = async (value) => {
 		if (typeof value !== "string") throw new ProjectError("PROJECT_PATH_INVALID_TYPE", "project path must be a string or null");
@@ -20421,6 +20550,7 @@ var ProjectManager = class {
 			updatedAt: now
 		};
 		await this.store.save([...projects, project]);
+		await this.options.onProjectRegistered?.(structuredClone(project));
 		return structuredClone(project);
 	};
 	assertNotDefaultWorkspace = async (rootPath) => {
@@ -20478,81 +20608,971 @@ var ProjectManager = class {
 	isMissingFileError = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 };
 //#endregion
-//#region src/features/projects/types/project-observation.types.ts
-const PROJECT_OBSERVATION_PROTOCOL = "nextclaw.project/v1";
-var ProjectObservationError = class extends Error {
-	constructor(code, message) {
-		super(message);
-		this.code = code;
-		this.name = "ProjectObservationError";
+//#region src/stores/sqlite-database.store.ts
+const require = createRequire(import.meta.url);
+const portableDatabases = /* @__PURE__ */ new Map();
+async function openSqliteDatabase(databasePath) {
+	try {
+		return new (require("node:sqlite")).DatabaseSync(databasePath);
+	} catch (error) {
+		if (!isMissingNodeSqlite(error)) throw error;
+		return await openPortableDatabase(databasePath);
+	}
+}
+function runSqliteTransaction(database, operation, mode = "DEFERRED") {
+	database.exec(`BEGIN ${mode}`);
+	try {
+		const result = operation();
+		database.exec("COMMIT");
+		return result;
+	} catch (error) {
+		database.exec("ROLLBACK");
+		throw error;
+	}
+}
+function isMissingNodeSqlite(error) {
+	const code = typeof error === "object" && error !== null ? error.code : void 0;
+	return code === "ERR_UNKNOWN_BUILTIN_MODULE" || code === "MODULE_NOT_FOUND";
+}
+async function openPortableDatabase(databasePath) {
+	const existing = portableDatabases.get(databasePath);
+	if (existing) return (await existing).acquire();
+	const opening = createPortableDatabase(databasePath).catch((error) => {
+		portableDatabases.delete(databasePath);
+		throw error;
+	});
+	portableDatabases.set(databasePath, opening);
+	return (await opening).acquire();
+}
+async function createPortableDatabase(databasePath) {
+	const initialize = (await import("sql.js")).default;
+	const sqlite = await initialize({ locateFile: (file) => require.resolve(`sql.js/dist/${file}`) });
+	return new PortableSqliteDatabase(databasePath, existsSync(databasePath) ? new sqlite.Database(readFileSync(databasePath)) : new sqlite.Database());
+}
+var PortableSqliteDatabase = class {
+	inTransaction = false;
+	dirty = false;
+	leaseCount = 0;
+	constructor(databasePath, database) {
+		this.databasePath = databasePath;
+		this.database = database;
+	}
+	acquire = () => {
+		this.leaseCount += 1;
+		return new PortableSqliteLease(this);
+	};
+	exec = (sql) => {
+		const command = sql.trim().toUpperCase();
+		this.database.run(sql);
+		if (command.startsWith("BEGIN")) {
+			this.inTransaction = true;
+			return;
+		}
+		if (command.startsWith("ROLLBACK")) {
+			this.inTransaction = false;
+			this.dirty = false;
+			return;
+		}
+		if (command.startsWith("COMMIT")) {
+			this.inTransaction = false;
+			this.persistIfDirty();
+			return;
+		}
+		if (!command.startsWith("PRAGMA")) this.markDirty();
+	};
+	prepare = (sql) => new PortableSqliteStatement(this, sql);
+	release = () => {
+		this.leaseCount -= 1;
+		if (this.leaseCount > 0) return;
+		this.persistIfDirty();
+		this.database.close();
+		portableDatabases.delete(this.databasePath);
+	};
+	run = (sql, params) => {
+		this.database.run(sql, normalizeParams(params));
+		this.markDirty();
+	};
+	readRows = (sql, params) => {
+		const statement = this.database.prepare(sql);
+		try {
+			bindStatement(statement, params);
+			const rows = [];
+			while (statement.step()) rows.push(statement.getAsObject());
+			return rows;
+		} finally {
+			statement.free();
+		}
+	};
+	markDirty = () => {
+		this.dirty = true;
+		if (!this.inTransaction) this.persistIfDirty();
+	};
+	persistIfDirty = () => {
+		if (!this.dirty) return;
+		const temporaryPath = `${this.databasePath}.tmp`;
+		writeFileSync(temporaryPath, this.database.export());
+		renameSync(temporaryPath, this.databasePath);
+		this.dirty = false;
+	};
+};
+var PortableSqliteLease = class {
+	closed = false;
+	constructor(owner) {
+		this.owner = owner;
+	}
+	close = () => {
+		if (this.closed) return;
+		this.closed = true;
+		this.owner.release();
+	};
+	exec = (sql) => this.owner.exec(sql);
+	prepare = (sql) => this.owner.prepare(sql);
+};
+var PortableSqliteStatement = class {
+	constructor(database, sql) {
+		this.database = database;
+		this.sql = sql;
 	}
+	all = (...params) => this.database.readRows(this.sql, params);
+	get = (...params) => this.all(...params)[0];
+	run = (...params) => {
+		this.database.run(this.sql, params);
+		return {};
+	};
 };
-function isProjectObservationError(error) {
-	return error instanceof ProjectObservationError;
+function bindStatement(statement, params) {
+	const normalized = normalizeParams(params);
+	if (Array.isArray(normalized) && normalized.length === 0) return;
+	statement.bind(normalized);
+}
+function normalizeParams(params) {
+	if (params.length !== 1 || !isRecord$9(params[0])) return params;
+	return Object.fromEntries(Object.entries(params[0]).map(([key, value]) => [`@${key}`, value]));
+}
+function isRecord$9(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
-//#region src/features/projects/utils/project-observation-config.utils.ts
-const isRecord$9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const readString$7 = (value) => {
-	if (typeof value !== "string") return null;
-	return value.trim() || null;
-};
-const collectUnknownKeyIssues = (value, allowed, owner) => Object.keys(value).flatMap((key) => allowed.includes(key) ? [] : [{
-	code: "PROJECT_CONFIG_UNKNOWN_FIELD",
-	message: `${owner} contains unknown field '${key}'.`
-}]);
-function parseContext(value) {
-	if (value === void 0) return {
-		value: [],
-		issues: []
+//#region src/features/projects/stores/project-work-activity.store.ts
+var ProjectWorkActivityStore = class {
+	constructor(db) {
+		this.db = db;
+	}
+	listActivities = async (projectId, workItemId, options) => {
+		const { cursor, limit } = options;
+		const cursorSequence = cursor ? Number(cursor) : null;
+		if (cursorSequence !== null && !Number.isInteger(cursorSequence)) throw new Error("PROJECT_WORK_ACTIVITY_CURSOR_INVALID");
+		const rows = this.db().prepare(`SELECT rowid AS sequence, * FROM project_work_activities
+         WHERE project_id = ? AND work_item_id = ? ${cursorSequence !== null ? "AND rowid < ?" : ""}
+         ORDER BY rowid DESC LIMIT ?`).all(projectId, workItemId, ...cursorSequence !== null ? [cursorSequence] : [], limit + 1);
+		const hasMore = rows.length > limit;
+		const pageRows = rows.slice(0, limit);
+		return {
+			activities: pageRows.map(toActivity),
+			nextCursor: hasMore ? String(pageRows.at(-1)?.sequence) : null
+		};
 	};
-	if (!Array.isArray(value)) return {
-		value: [],
-		issues: [{
-			code: "PROJECT_CONFIG_CONTEXT_INVALID",
-			message: "project.context must be an array."
-		}]
+	listArtifacts = async (projectId, workItemId) => this.db().prepare(`SELECT * FROM project_work_artifact_links
+           WHERE project_id = ? AND work_item_id = ? ORDER BY created_at DESC`).all(projectId, workItemId).map(toArtifactLink);
+	linkArtifact = async (params) => {
+		const { actor, label, path, projectId, workItemId } = params;
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const id = randomUUID();
+		runSqliteTransaction(this.db(), () => {
+			this.db().prepare(`INSERT INTO project_work_artifact_links
+             (id, project_id, work_item_id, path, label, created_at) VALUES (?, ?, ?, ?, ?, ?)`).run(id, projectId, workItemId, path, label ?? null, now);
+			this.insertActivity({
+				projectId,
+				workItemId,
+				type: "artifact-linked",
+				actor,
+				details: {
+					artifactLinkId: id,
+					path
+				},
+				createdAt: now
+			});
+		}, "IMMEDIATE");
+		return (await this.listArtifacts(projectId, workItemId)).find((link) => link.id === id);
 	};
-	const issues = [];
+	unlinkArtifact = async (params) => {
+		const { actor, artifactLinkId, projectId, workItemId } = params;
+		const link = this.db().prepare(`SELECT * FROM project_work_artifact_links
+         WHERE project_id = ? AND work_item_id = ? AND id = ? LIMIT 1`).get(projectId, workItemId, artifactLinkId);
+		if (!link) return false;
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		runSqliteTransaction(this.db(), () => {
+			this.db().prepare("DELETE FROM project_work_artifact_links WHERE project_id = ? AND work_item_id = ? AND id = ?").run(projectId, workItemId, artifactLinkId);
+			this.insertActivity({
+				projectId,
+				workItemId,
+				type: "artifact-unlinked",
+				actor,
+				details: {
+					artifactLinkId: link.id,
+					path: link.path
+				},
+				createdAt: now
+			});
+		}, "IMMEDIATE");
+		return true;
+	};
+	insertActivity = (activity) => {
+		this.db().prepare(`INSERT INTO project_work_activities
+         (id, project_id, work_item_id, type, actor_json, details_json, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), activity.projectId, activity.workItemId, activity.type, JSON.stringify(activity.actor), JSON.stringify(activity.details), activity.createdAt);
+	};
+};
+function toActivity(row) {
 	return {
-		value: value.flatMap((entry, index) => {
-			if (!isRecord$9(entry)) {
-				issues.push({
-					code: "PROJECT_CONFIG_CONTEXT_INVALID",
-					message: `project.context[${index}] must be an object.`
-				});
-				return [];
-			}
-			issues.push(...collectUnknownKeyIssues(entry, [
-				"id",
-				"role",
-				"source"
-			], `project.context[${index}]`));
-			const id = readString$7(entry.id);
-			const role = readString$7(entry.role);
-			const source = readString$7(entry.source);
-			if (!id || !role || !source) {
-				issues.push({
-					code: "PROJECT_CONFIG_CONTEXT_INVALID",
-					message: `project.context[${index}] requires id, role and source.`
-				});
-				return [];
-			}
-			return [{
-				id,
-				role,
-				source
-			}];
-		}),
-		issues
+		id: row.id,
+		projectId: row.project_id,
+		workItemId: row.work_item_id,
+		type: row.type,
+		actor: JSON.parse(row.actor_json),
+		details: JSON.parse(row.details_json),
+		createdAt: row.created_at
 	};
 }
-function parseWorkflows(value) {
-	if (value === void 0) return {
-		value: [],
-		issues: []
+function toArtifactLink(row) {
+	return {
+		id: row.id,
+		projectId: row.project_id,
+		workItemId: row.work_item_id,
+		path: row.path,
+		label: row.label,
+		createdAt: row.created_at
 	};
-	if (!Array.isArray(value)) return {
+}
+//#endregion
+//#region src/features/projects/stores/project-work-state.store.ts
+const DEFAULT_PROJECT_WORK_STATES = [
+	{
+		name: "Backlog",
+		category: "backlog",
+		position: 0,
+		isDefault: false
+	},
+	{
+		name: "Planned",
+		category: "unstarted",
+		position: 1,
+		isDefault: true
+	},
+	{
+		name: "In Progress",
+		category: "started",
+		position: 2,
+		isDefault: false
+	},
+	{
+		name: "In Review",
+		category: "started",
+		position: 3,
+		isDefault: false
+	},
+	{
+		name: "Awaiting Acceptance",
+		category: "started",
+		position: 4,
+		isDefault: false
+	},
+	{
+		name: "Completed",
+		category: "completed",
+		position: 5,
+		isDefault: false
+	},
+	{
+		name: "Canceled",
+		category: "canceled",
+		position: 6,
+		isDefault: false
+	}
+];
+var ProjectWorkStateStore = class {
+	constructor(db, insertActivity) {
+		this.db = db;
+		this.insertActivity = insertActivity;
+	}
+	ensureProject = async (projectId) => {
+		if (this.db().prepare("SELECT COUNT(*) AS total FROM project_work_states WHERE project_id = ?").get(projectId).total > 0) return;
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		runSqliteTransaction(this.db(), () => {
+			if (this.db().prepare("SELECT COUNT(*) AS total FROM project_work_states WHERE project_id = ?").get(projectId).total > 0) return;
+			const insert = this.db().prepare(`INSERT INTO project_work_states
+           (id, project_id, name, category, position, is_default, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+			for (const state of DEFAULT_PROJECT_WORK_STATES) insert.run(randomUUID(), projectId, state.name, state.category, state.position, state.isDefault ? 1 : 0, now, now);
+		}, "IMMEDIATE");
+	};
+	listStates = async (projectId) => this.db().prepare("SELECT * FROM project_work_states WHERE project_id = ? ORDER BY position, created_at").all(projectId).map(toState);
+	getState = async (projectId, stateId) => {
+		const row = this.db().prepare("SELECT * FROM project_work_states WHERE project_id = ? AND id = ? LIMIT 1").get(projectId, stateId);
+		return row ? toState(row) : null;
+	};
+	createState = async (projectId, input) => {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const id = randomUUID();
+		const position = input.position ?? this.nextStatePosition(projectId);
+		runSqliteTransaction(this.db(), () => {
+			if (input.isDefault) this.clearDefaultState(projectId);
+			this.db().prepare(`INSERT INTO project_work_states
+             (id, project_id, name, category, position, is_default, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, projectId, input.name, input.category, position, input.isDefault ? 1 : 0, now, now);
+		}, "IMMEDIATE");
+		return await this.getState(projectId, id);
+	};
+	updateState = async (projectId, stateId, input) => {
+		const current = await this.getState(projectId, stateId);
+		if (!current) return null;
+		const next = {
+			...current,
+			...input,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		runSqliteTransaction(this.db(), () => {
+			if (next.isDefault) this.clearDefaultState(projectId);
+			this.db().prepare(`UPDATE project_work_states
+             SET name = ?, category = ?, position = ?, is_default = ?, updated_at = ?
+             WHERE project_id = ? AND id = ?`).run(next.name, next.category, next.position, next.isDefault ? 1 : 0, next.updatedAt, projectId, stateId);
+		}, "IMMEDIATE");
+		return await this.getState(projectId, stateId);
+	};
+	deleteState = async (projectId, stateId, migrateToStateId, actor) => {
+		const current = await this.getState(projectId, stateId);
+		if (!current) return false;
+		runSqliteTransaction(this.db(), () => {
+			if (this.db().prepare("SELECT COUNT(*) AS total FROM project_work_items WHERE project_id = ? AND state_id = ?").get(projectId, stateId).total > 0 && !migrateToStateId) throw new Error("PROJECT_WORK_STATE_IN_USE");
+			if (migrateToStateId) this.migrateItems(projectId, stateId, migrateToStateId, actor);
+			this.db().prepare("DELETE FROM project_work_states WHERE project_id = ? AND id = ?").run(projectId, stateId);
+			if (current.isDefault) this.assignReplacementDefault(projectId, migrateToStateId);
+		}, "IMMEDIATE");
+		return true;
+	};
+	migrateItems = (projectId, stateId, migrateToStateId, actor) => {
+		const affected = this.db().prepare("SELECT id FROM project_work_items WHERE project_id = ? AND state_id = ?").all(projectId, stateId);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		this.db().prepare(`UPDATE project_work_items
+         SET state_id = ?, version = version + 1, updated_at = ?
+         WHERE project_id = ? AND state_id = ?`).run(migrateToStateId, now, projectId, stateId);
+		for (const item of affected) this.insertActivity({
+			projectId,
+			workItemId: item.id,
+			type: "state-changed",
+			actor,
+			details: {
+				fromStateId: stateId,
+				toStateId: migrateToStateId,
+				reason: "state-deleted"
+			},
+			createdAt: now
+		});
+	};
+	assignReplacementDefault = (projectId, migrateToStateId) => {
+		const replacement = migrateToStateId ?? this.db().prepare("SELECT id FROM project_work_states WHERE project_id = ? ORDER BY position LIMIT 1").get(projectId)?.id;
+		if (replacement) this.db().prepare("UPDATE project_work_states SET is_default = 1 WHERE project_id = ? AND id = ?").run(projectId, replacement);
+	};
+	nextStatePosition = (projectId) => {
+		return this.db().prepare("SELECT COALESCE(MAX(position), -1) + 1 AS position FROM project_work_states WHERE project_id = ?").get(projectId).position;
+	};
+	clearDefaultState = (projectId) => {
+		this.db().prepare("UPDATE project_work_states SET is_default = 0 WHERE project_id = ?").run(projectId);
+	};
+};
+function toState(row) {
+	return {
+		id: row.id,
+		projectId: row.project_id,
+		name: row.name,
+		category: row.category,
+		position: row.position,
+		isDefault: Boolean(row.is_default),
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+//#endregion
+//#region src/features/projects/stores/project-work.store.ts
+var ProjectWorkStore = class {
+	database = null;
+	readyPromise = null;
+	activities = new ProjectWorkActivityStore(() => this.db());
+	states = new ProjectWorkStateStore(() => this.db(), this.activities.insertActivity);
+	constructor(databasePath) {
+		this.databasePath = databasePath;
+	}
+	initialize = async () => await this.ensureReady();
+	close = () => {
+		this.database?.close();
+		this.database = null;
+		this.readyPromise = null;
+	};
+	ensureProject = async (projectId) => {
+		await this.ensureReady();
+		await this.states.ensureProject(projectId);
+	};
+	listStates = async (projectId) => {
+		await this.ensureReady();
+		return await this.states.listStates(projectId);
+	};
+	getState = async (projectId, stateId) => {
+		await this.ensureReady();
+		return await this.states.getState(projectId, stateId);
+	};
+	createState = async (projectId, input) => {
+		await this.ensureReady();
+		return await this.states.createState(projectId, input);
+	};
+	updateState = async (projectId, stateId, input) => {
+		await this.ensureReady();
+		return await this.states.updateState(projectId, stateId, input);
+	};
+	deleteState = async (projectId, stateId, migrateToStateId, actor) => {
+		await this.ensureReady();
+		return await this.states.deleteState(projectId, stateId, migrateToStateId, actor);
+	};
+	listItems = async (projectId, includeDeleted = false) => {
+		await this.ensureReady();
+		return this.db().prepare(`SELECT * FROM project_work_items
+       WHERE project_id = ? ${includeDeleted ? "" : "AND deleted_at IS NULL"}
+       ORDER BY updated_at DESC, created_at DESC`).all(projectId).map(toItem);
+	};
+	getItem = async (projectId, workItemId) => {
+		await this.ensureReady();
+		const row = this.db().prepare("SELECT * FROM project_work_items WHERE project_id = ? AND id = ? LIMIT 1").get(projectId, workItemId);
+		return row ? toItem(row) : null;
+	};
+	createItem = async (params) => {
+		await this.ensureReady();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const id = randomUUID();
+		runSqliteTransaction(this.db(), () => {
+			this.db().prepare(`INSERT INTO project_work_items
+         (id, project_id, title, description, state_id, attention, version, created_at, updated_at, deleted_at)
+         VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?, NULL)`).run(id, params.projectId, params.input.title, params.input.description ?? "", params.stateId, params.input.attention ?? "none", now, now);
+			this.activities.insertActivity({
+				projectId: params.projectId,
+				workItemId: id,
+				type: "created",
+				actor: params.actor,
+				details: { stateId: params.stateId },
+				createdAt: now
+			});
+		}, "IMMEDIATE");
+		return await this.getItem(params.projectId, id);
+	};
+	updateItem = async (params) => {
+		await this.ensureReady();
+		const { actor, input, projectId, workItemId } = params;
+		const current = await this.getItem(projectId, workItemId);
+		if (!current) return null;
+		if (input.expectedVersion !== void 0 && input.expectedVersion !== current.version) throw new Error("PROJECT_WORK_VERSION_CONFLICT");
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const next = {
+			...current,
+			...input
+		};
+		runSqliteTransaction(this.db(), () => {
+			this.db().prepare(`UPDATE project_work_items SET title = ?, description = ?, state_id = ?, attention = ?,
+         version = version + 1, updated_at = ? WHERE project_id = ? AND id = ?`).run(next.title, next.description, next.stateId, next.attention, now, projectId, workItemId);
+			const stateChanged = next.stateId !== current.stateId;
+			this.activities.insertActivity({
+				projectId,
+				workItemId,
+				type: stateChanged ? "state-changed" : "updated",
+				actor,
+				details: stateChanged ? {
+					fromStateId: current.stateId,
+					toStateId: next.stateId
+				} : changedItemFields(current, next),
+				createdAt: now
+			});
+		}, "IMMEDIATE");
+		return await this.getItem(projectId, workItemId);
+	};
+	setDeleted = async (params) => {
+		await this.ensureReady();
+		const { actor, deleted, projectId, workItemId } = params;
+		if (!await this.getItem(projectId, workItemId)) return null;
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		runSqliteTransaction(this.db(), () => {
+			this.db().prepare(`UPDATE project_work_items SET deleted_at = ?, version = version + 1, updated_at = ?
+         WHERE project_id = ? AND id = ?`).run(deleted ? now : null, now, projectId, workItemId);
+			this.activities.insertActivity({
+				projectId,
+				workItemId,
+				type: deleted ? "deleted" : "restored",
+				actor,
+				details: {},
+				createdAt: now
+			});
+		}, "IMMEDIATE");
+		return await this.getItem(projectId, workItemId);
+	};
+	listActivities = async (projectId, workItemId, options) => {
+		await this.ensureReady();
+		return await this.activities.listActivities(projectId, workItemId, options);
+	};
+	listArtifacts = async (projectId, workItemId) => {
+		await this.ensureReady();
+		return await this.activities.listArtifacts(projectId, workItemId);
+	};
+	linkArtifact = async (params) => {
+		await this.ensureReady();
+		return await this.activities.linkArtifact(params);
+	};
+	unlinkArtifact = async (params) => {
+		await this.ensureReady();
+		return await this.activities.unlinkArtifact(params);
+	};
+	ensureReady = async () => {
+		this.readyPromise ??= this.open();
+		await this.readyPromise;
+	};
+	open = async () => {
+		await mkdir(dirname(this.databasePath), { recursive: true });
+		this.database = await openSqliteDatabase(this.databasePath);
+		this.database.exec(`
+      PRAGMA busy_timeout = 10000;
+      PRAGMA journal_mode = WAL;
+      PRAGMA synchronous = NORMAL;
+      PRAGMA foreign_keys = ON;
+      CREATE TABLE IF NOT EXISTS project_work_states (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        category TEXT NOT NULL,
+        position INTEGER NOT NULL,
+        is_default INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(project_id, name)
+      );
+      CREATE TABLE IF NOT EXISTS project_work_items (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        title TEXT NOT NULL,
+        description TEXT NOT NULL DEFAULT '',
+        state_id TEXT NOT NULL,
+        attention TEXT NOT NULL DEFAULT 'none',
+        version INTEGER NOT NULL DEFAULT 1,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        deleted_at TEXT,
+        FOREIGN KEY(state_id) REFERENCES project_work_states(id)
+      );
+      CREATE TABLE IF NOT EXISTS project_work_activities (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        work_item_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        actor_json TEXT NOT NULL,
+        details_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY(work_item_id) REFERENCES project_work_items(id)
+      );
+      CREATE TABLE IF NOT EXISTS project_work_artifact_links (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        work_item_id TEXT NOT NULL,
+        path TEXT NOT NULL,
+        label TEXT,
+        created_at TEXT NOT NULL,
+        UNIQUE(project_id, work_item_id, path),
+        FOREIGN KEY(work_item_id) REFERENCES project_work_items(id)
+      );
+      CREATE INDEX IF NOT EXISTS project_work_items_list_idx
+      ON project_work_items(project_id, deleted_at, updated_at);
+      CREATE INDEX IF NOT EXISTS project_work_activity_timeline_idx
+      ON project_work_activities(project_id, work_item_id, created_at);
+    `);
+	};
+	db = () => {
+		if (!this.database) throw new Error("Project work database is not initialized.");
+		return this.database;
+	};
+};
+function toItem(row) {
+	return {
+		id: row.id,
+		projectId: row.project_id,
+		title: row.title,
+		description: row.description,
+		stateId: row.state_id,
+		attention: row.attention,
+		version: row.version,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		deletedAt: row.deleted_at
+	};
+}
+function changedItemFields(current, next) {
+	const fields = {};
+	if (current.title !== next.title) fields.title = {
+		from: current.title,
+		to: next.title
+	};
+	if (current.description !== next.description) fields.descriptionChanged = true;
+	if (current.attention !== next.attention) fields.attention = {
+		from: current.attention,
+		to: next.attention
+	};
+	return fields;
+}
+//#endregion
+//#region src/features/projects/types/project-work-error.types.ts
+var ProjectWorkError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "ProjectWorkError";
+	}
+};
+function isProjectWorkError(error) {
+	return error instanceof ProjectWorkError;
+}
+//#endregion
+//#region src/features/projects/types/project-work.types.ts
+const PROJECT_WORK_STATE_CATEGORIES = [
+	"backlog",
+	"unstarted",
+	"started",
+	"completed",
+	"canceled"
+];
+const PROJECT_WORK_ATTENTION_VALUES = [
+	"none",
+	"blocked",
+	"awaiting-user"
+];
+//#endregion
+//#region src/features/projects/managers/project-work.manager.ts
+var ProjectWorkManager = class {
+	store;
+	constructor(options) {
+		this.options = options;
+		this.store = new ProjectWorkStore(options.databasePath);
+	}
+	initialize = async () => {
+		await this.store.initialize();
+		for (const project of await this.options.projectManager.listProjects()) await this.store.ensureProject(project.id);
+	};
+	dispose = () => this.store.close();
+	ensureProject = async (projectId) => {
+		await this.requireProject(projectId);
+		await this.store.ensureProject(projectId);
+	};
+	list = async (projectId, includeDeleted = false) => {
+		await this.ensureProject(projectId);
+		const [states, items] = await Promise.all([this.store.listStates(projectId), this.store.listItems(projectId, includeDeleted)]);
+		const stateById = new Map(states.map((state) => [state.id, state]));
+		const detailed = await Promise.all(items.map(async (item) => ({
+			...item,
+			state: this.requireMappedState(stateById, item.stateId),
+			artifacts: await this.store.listArtifacts(projectId, item.id)
+		})));
+		return {
+			items: detailed,
+			states,
+			total: detailed.length
+		};
+	};
+	summary = async (projectId) => {
+		const { items } = await this.list(projectId);
+		return {
+			total: items.length,
+			active: items.filter((item) => item.state.category !== "completed" && item.state.category !== "canceled").length,
+			completed: items.filter((item) => item.state.category === "completed").length,
+			attention: items.filter((item) => item.attention !== "none").length,
+			updatedAt: items[0]?.updatedAt ?? null
+		};
+	};
+	get = async (projectId, workItemId) => {
+		await this.ensureProject(projectId);
+		const item = await this.store.getItem(projectId, workItemId);
+		if (!item) throw new ProjectWorkError("PROJECT_WORK_ITEM_NOT_FOUND", "work item was not found");
+		const state = await this.store.getState(projectId, item.stateId);
+		if (!state) throw new ProjectWorkError("PROJECT_WORK_STATE_NOT_FOUND", "work item state was not found");
+		return {
+			...item,
+			state,
+			artifacts: await this.store.listArtifacts(projectId, workItemId)
+		};
+	};
+	create = async (projectId, input, actor) => {
+		await this.ensureProject(projectId);
+		const title = this.requireName(input.title, "work item title");
+		const attention = input.attention ?? "none";
+		this.assertAttention(attention);
+		const states = await this.store.listStates(projectId);
+		const state = input.stateId ? states.find((entry) => entry.id === input.stateId) : states.find((entry) => entry.isDefault);
+		if (!state) throw new ProjectWorkError("PROJECT_WORK_STATE_NOT_FOUND", "work item state was not found");
+		const item = await this.store.createItem({
+			projectId,
+			actor: this.normalizeActor(actor),
+			stateId: state.id,
+			input: {
+				title,
+				description: input.description?.trim() ?? "",
+				attention
+			}
+		});
+		await this.emit(projectId, "created", item.id);
+		return await this.get(projectId, item.id);
+	};
+	update = async (projectId, workItemId, input, actor) => {
+		await this.ensureProject(projectId);
+		const current = await this.get(projectId, workItemId);
+		if (input.expectedVersion !== void 0 && input.expectedVersion !== current.version) throw new ProjectWorkError("PROJECT_WORK_VERSION_CONFLICT", "work item changed since it was loaded");
+		const normalizedInput = {
+			...input,
+			...input.title !== void 0 ? { title: this.requireName(input.title, "work item title") } : {},
+			...input.description !== void 0 ? { description: input.description.trim() } : {}
+		};
+		if (normalizedInput.attention !== void 0) this.assertAttention(normalizedInput.attention);
+		if (normalizedInput.stateId !== void 0 && !await this.store.getState(projectId, normalizedInput.stateId)) throw new ProjectWorkError("PROJECT_WORK_STATE_NOT_FOUND", "work item state was not found");
+		if ((normalizedInput.title === void 0 || normalizedInput.title === current.title) && (normalizedInput.description === void 0 || normalizedInput.description === current.description) && (normalizedInput.stateId === void 0 || normalizedInput.stateId === current.stateId) && (normalizedInput.attention === void 0 || normalizedInput.attention === current.attention)) return current;
+		let item;
+		try {
+			item = await this.store.updateItem({
+				projectId,
+				workItemId,
+				input: normalizedInput,
+				actor: this.normalizeActor(actor)
+			});
+		} catch (error) {
+			if (error instanceof Error && error.message === "PROJECT_WORK_VERSION_CONFLICT") throw new ProjectWorkError("PROJECT_WORK_VERSION_CONFLICT", "work item changed since it was loaded");
+			throw error;
+		}
+		if (!item) throw new ProjectWorkError("PROJECT_WORK_ITEM_NOT_FOUND", "work item was not found");
+		await this.emit(projectId, "updated", workItemId);
+		return await this.get(projectId, workItemId);
+	};
+	delete = async (projectId, workItemId, actor) => {
+		return await this.setDeleted(projectId, workItemId, true, actor);
+	};
+	restore = async (projectId, workItemId, actor) => {
+		return await this.setDeleted(projectId, workItemId, false, actor);
+	};
+	listActivities = async (projectId, workItemId, options = {}) => {
+		await this.get(projectId, workItemId);
+		if (options.cursor && !/^\d+$/.test(options.cursor)) throw new ProjectWorkError("PROJECT_WORK_VALIDATION_FAILED", "work item activity cursor is invalid");
+		return await this.store.listActivities(projectId, workItemId, {
+			...options.cursor ? { cursor: options.cursor } : {},
+			limit: Math.min(100, Math.max(1, options.limit ?? 50))
+		});
+	};
+	listStates = async (projectId) => {
+		await this.ensureProject(projectId);
+		return await this.store.listStates(projectId);
+	};
+	createState = async (projectId, input) => {
+		await this.ensureProject(projectId);
+		const normalized = {
+			...input,
+			name: this.requireName(input.name, "state name")
+		};
+		this.assertCategory(normalized.category);
+		if ((await this.store.listStates(projectId)).some((state) => state.name.toLocaleLowerCase() === normalized.name.toLocaleLowerCase())) throw new ProjectWorkError("PROJECT_WORK_STATE_INVALID", "state name is already in use");
+		const state = await this.store.createState(projectId, normalized);
+		await this.emit(projectId, "state-config");
+		return state;
+	};
+	updateState = async (projectId, stateId, input) => {
+		await this.ensureProject(projectId);
+		const normalizedInput = {
+			...input,
+			...input.name !== void 0 ? { name: this.requireName(input.name, "state name") } : {}
+		};
+		if (normalizedInput.category !== void 0) this.assertCategory(normalizedInput.category);
+		const current = await this.store.getState(projectId, stateId);
+		if (!current) throw new ProjectWorkError("PROJECT_WORK_STATE_NOT_FOUND", "work item state was not found");
+		if (current.isDefault && normalizedInput.isDefault === false) throw new ProjectWorkError("PROJECT_WORK_STATE_INVALID", "choose another default state before clearing this one");
+		if (normalizedInput.name && (await this.store.listStates(projectId)).some((state) => state.id !== stateId && state.name.toLocaleLowerCase() === normalizedInput.name.toLocaleLowerCase())) throw new ProjectWorkError("PROJECT_WORK_STATE_INVALID", "state name is already in use");
+		const state = await this.store.updateState(projectId, stateId, normalizedInput);
+		if (!state) throw new ProjectWorkError("PROJECT_WORK_STATE_NOT_FOUND", "work item state was not found");
+		await this.emit(projectId, "state-config");
+		return state;
+	};
+	deleteState = async (projectId, stateId, migrateToStateId, actor) => {
+		await this.ensureProject(projectId);
+		const states = await this.store.listStates(projectId);
+		if (states.length <= 1) throw new ProjectWorkError("PROJECT_WORK_STATE_INVALID", "a project must keep at least one state");
+		if (migrateToStateId === stateId) throw new ProjectWorkError("PROJECT_WORK_STATE_INVALID", "migration target must be a different state");
+		if (migrateToStateId && !states.some((state) => state.id === migrateToStateId)) throw new ProjectWorkError("PROJECT_WORK_STATE_NOT_FOUND", "migration target state was not found");
+		try {
+			if (!await this.store.deleteState(projectId, stateId, migrateToStateId, this.normalizeActor(actor))) throw new ProjectWorkError("PROJECT_WORK_STATE_NOT_FOUND", "work item state was not found");
+		} catch (error) {
+			if (error instanceof Error && error.message === "PROJECT_WORK_STATE_IN_USE") throw new ProjectWorkError("PROJECT_WORK_STATE_IN_USE", "state is used by work items; choose a migration target");
+			throw error;
+		}
+		await this.emit(projectId, "state-config");
+	};
+	linkArtifact = async (params) => {
+		const { actor, label, path, projectId, workItemId } = params;
+		const project = await this.requireProject(projectId);
+		await this.get(projectId, workItemId);
+		const artifactPath = await this.normalizeArtifactPath(project.rootPath, path);
+		const existing = (await this.store.listArtifacts(projectId, workItemId)).find((link) => link.path === artifactPath);
+		if (existing) return existing;
+		const link = await this.store.linkArtifact({
+			projectId,
+			workItemId,
+			path: artifactPath,
+			label: label?.trim() || void 0,
+			actor: this.normalizeActor(actor)
+		});
+		await this.emit(projectId, "artifact", workItemId);
+		return link;
+	};
+	unlinkArtifact = async (params) => {
+		const { actor, artifactLinkId, projectId, workItemId } = params;
+		await this.get(projectId, workItemId);
+		if (!await this.store.unlinkArtifact({
+			projectId,
+			workItemId,
+			artifactLinkId,
+			actor: this.normalizeActor(actor)
+		})) throw new ProjectWorkError("PROJECT_WORK_ARTIFACT_NOT_FOUND", "artifact link was not found");
+		await this.emit(projectId, "artifact", workItemId);
+	};
+	setDeleted = async (projectId, workItemId, deleted, actor) => {
+		await this.ensureProject(projectId);
+		const current = await this.get(projectId, workItemId);
+		if (current.deletedAt !== null === deleted) return current;
+		if (!await this.store.setDeleted({
+			projectId,
+			workItemId,
+			deleted,
+			actor: this.normalizeActor(actor)
+		})) throw new ProjectWorkError("PROJECT_WORK_ITEM_NOT_FOUND", "work item was not found");
+		await this.emit(projectId, deleted ? "deleted" : "restored", workItemId);
+		return await this.get(projectId, workItemId);
+	};
+	requireProject = async (projectId) => {
+		const normalized = projectId.trim();
+		const project = normalized ? await this.options.projectManager.getProjectById(normalized) : null;
+		if (!project) throw new ProjectWorkError("PROJECT_NOT_FOUND", "project was not found");
+		return project;
+	};
+	requireMappedState = (states, stateId) => {
+		const state = states.get(stateId);
+		if (!state) throw new ProjectWorkError("PROJECT_WORK_STATE_NOT_FOUND", "work item state was not found");
+		return state;
+	};
+	requireName = (value, label) => {
+		const normalized = typeof value === "string" ? value.trim() : "";
+		if (!normalized) throw new ProjectWorkError("PROJECT_WORK_VALIDATION_FAILED", `${label} is required`);
+		if (normalized.length > 200) throw new ProjectWorkError("PROJECT_WORK_VALIDATION_FAILED", `${label} is too long`);
+		return normalized;
+	};
+	assertAttention = (value) => {
+		if (!PROJECT_WORK_ATTENTION_VALUES.some((entry) => entry === value)) throw new ProjectWorkError("PROJECT_WORK_VALIDATION_FAILED", "work item attention is invalid");
+	};
+	assertCategory = (value) => {
+		if (!PROJECT_WORK_STATE_CATEGORIES.some((entry) => entry === value)) throw new ProjectWorkError("PROJECT_WORK_VALIDATION_FAILED", "work item state category is invalid");
+	};
+	normalizeActor = (actor) => ({
+		kind: actor.kind,
+		...actor.id?.trim() ? { id: actor.id.trim() } : {},
+		...actor.sessionId?.trim() ? { sessionId: actor.sessionId.trim() } : {}
+	});
+	normalizeArtifactPath = async (rootPath, inputPath) => {
+		const requested = inputPath.trim();
+		if (!requested) throw new ProjectWorkError("PROJECT_WORK_ARTIFACT_INVALID", "artifact path is required");
+		const canonicalRoot = await realpath(rootPath);
+		const candidate = await realpath(isAbsolute(requested) ? requested : resolve(canonicalRoot, requested)).catch(() => null);
+		if (!candidate) throw new ProjectWorkError("PROJECT_WORK_ARTIFACT_NOT_FOUND", "artifact file does not exist");
+		const relativePath = relative(canonicalRoot, candidate);
+		if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) throw new ProjectWorkError("PROJECT_WORK_ARTIFACT_INVALID", "artifact must be a file inside the project root");
+		if (!(await stat(candidate)).isFile()) throw new ProjectWorkError("PROJECT_WORK_ARTIFACT_INVALID", "artifact must be a file");
+		return relativePath.split(sep).join("/");
+	};
+	emit = async (projectId, change, workItemId) => {
+		await this.options.eventBus.emit(eventKeys$1.projectWorkChanged, {
+			projectId,
+			change,
+			...workItemId ? { workItemId } : {}
+		});
+	};
+};
+//#endregion
+//#region src/features/projects/types/project-observation.types.ts
+const PROJECT_OBSERVATION_PROTOCOL = "nextclaw.project/v1";
+var ProjectObservationError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "ProjectObservationError";
+	}
+};
+function isProjectObservationError(error) {
+	return error instanceof ProjectObservationError;
+}
+//#endregion
+//#region src/features/projects/utils/project-observation-config.utils.ts
+const isRecord$8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const readString$7 = (value) => {
+	if (typeof value !== "string") return null;
+	return value.trim() || null;
+};
+const collectUnknownKeyIssues = (value, allowed, owner) => Object.keys(value).flatMap((key) => allowed.includes(key) ? [] : [{
+	code: "PROJECT_CONFIG_UNKNOWN_FIELD",
+	message: `${owner} contains unknown field '${key}'.`
+}]);
+function parseContext(value) {
+	if (value === void 0) return {
+		value: [],
+		issues: []
+	};
+	if (!Array.isArray(value)) return {
+		value: [],
+		issues: [{
+			code: "PROJECT_CONFIG_CONTEXT_INVALID",
+			message: "project.context must be an array."
+		}]
+	};
+	const issues = [];
+	return {
+		value: value.flatMap((entry, index) => {
+			if (!isRecord$8(entry)) {
+				issues.push({
+					code: "PROJECT_CONFIG_CONTEXT_INVALID",
+					message: `project.context[${index}] must be an object.`
+				});
+				return [];
+			}
+			issues.push(...collectUnknownKeyIssues(entry, [
+				"id",
+				"role",
+				"source"
+			], `project.context[${index}]`));
+			const id = readString$7(entry.id);
+			const role = readString$7(entry.role);
+			const source = readString$7(entry.source);
+			if (!id || !role || !source) {
+				issues.push({
+					code: "PROJECT_CONFIG_CONTEXT_INVALID",
+					message: `project.context[${index}] requires id, role and source.`
+				});
+				return [];
+			}
+			return [{
+				id,
+				role,
+				source
+			}];
+		}),
+		issues
+	};
+}
+function parseWorkflows(value) {
+	if (value === void 0) return {
+		value: [],
+		issues: []
+	};
+	if (!Array.isArray(value)) return {
 		value: [],
 		issues: [{
 			code: "PROJECT_CONFIG_WORKFLOWS_INVALID",
@@ -20562,7 +21582,7 @@ function parseWorkflows(value) {
 	const issues = [];
 	return {
 		value: value.flatMap((entry, workflowIndex) => {
-			if (!isRecord$9(entry) || !Array.isArray(entry.stages)) {
+			if (!isRecord$8(entry) || !Array.isArray(entry.stages)) {
 				issues.push({
 					code: "PROJECT_CONFIG_WORKFLOW_INVALID",
 					message: `workflows[${workflowIndex}] requires a stages array.`
@@ -20577,7 +21597,7 @@ function parseWorkflows(value) {
 			const id = readString$7(entry.id);
 			const label = readString$7(entry.label);
 			const stages = entry.stages.flatMap((stage, stageIndex) => {
-				if (!isRecord$9(stage)) {
+				if (!isRecord$8(stage)) {
 					issues.push({
 						code: "PROJECT_CONFIG_STAGE_INVALID",
 						message: `workflows[${workflowIndex}].stages[${stageIndex}] must be an object.`
@@ -20630,7 +21650,7 @@ function parseArtifactCategories(value) {
 	const issues = [];
 	return {
 		value: value.flatMap((entry, index) => {
-			if (!isRecord$9(entry) || !Array.isArray(entry.include)) {
+			if (!isRecord$8(entry) || !Array.isArray(entry.include)) {
 				issues.push({
 					code: "PROJECT_CONFIG_ARTIFACT_INVALID",
 					message: `observation.artifacts[${index}] requires an include array.`
@@ -20676,7 +21696,7 @@ function parseSkillRoots(value) {
 	const issues = [];
 	return {
 		value: value.flatMap((entry, index) => {
-			if (!isRecord$9(entry)) {
+			if (!isRecord$8(entry)) {
 				issues.push({
 					code: "PROJECT_CONFIG_SKILL_INVALID",
 					message: `observation.skills[${index}] must be an object.`
@@ -20711,7 +21731,7 @@ function parseProjectObservationConfig(source) {
 			}]
 		};
 	}
-	if (!isRecord$9(parsed)) return {
+	if (!isRecord$8(parsed)) return {
 		config: null,
 		issues: [{
 			code: "PROJECT_CONFIG_INVALID",
@@ -20731,13 +21751,13 @@ function parseProjectObservationConfig(source) {
 			message: "Only schema_version 1 is supported."
 		}, ...issues]
 	};
-	const project = isRecord$9(parsed.project) ? parsed.project : {};
-	const observation = isRecord$9(parsed.observation) ? parsed.observation : {};
-	if (parsed.project !== void 0 && !isRecord$9(parsed.project)) issues.push({
+	const project = isRecord$8(parsed.project) ? parsed.project : {};
+	const observation = isRecord$8(parsed.observation) ? parsed.observation : {};
+	if (parsed.project !== void 0 && !isRecord$8(parsed.project)) issues.push({
 		code: "PROJECT_CONFIG_PROJECT_INVALID",
 		message: "project must be an object."
 	});
-	if (parsed.observation !== void 0 && !isRecord$9(parsed.observation)) issues.push({
+	if (parsed.observation !== void 0 && !isRecord$8(parsed.observation)) issues.push({
 		code: "PROJECT_CONFIG_OBSERVATION_INVALID",
 		message: "observation must be an object."
 	});
@@ -20749,7 +21769,7 @@ function parseProjectObservationConfig(source) {
 		"skills"
 	], "observation"));
 	if (observation.markers !== void 0) {
-		if (!(Array.isArray(observation.markers) ? observation.markers : []).some((marker) => isRecord$9(marker) && marker.protocol === "nextclaw.project/v1")) issues.push({
+		if (!(Array.isArray(observation.markers) ? observation.markers : []).some((marker) => isRecord$8(marker) && marker.protocol === "nextclaw.project/v1")) issues.push({
 			code: "PROJECT_CONFIG_MARKERS_INVALID",
 			message: `observation.markers must enable protocol '${PROJECT_OBSERVATION_PROTOCOL}'.`
 		});
@@ -21402,10 +22422,10 @@ function parseProjectObservationMarkers(params) {
 		issues
 	};
 }
-const isRecord$8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function readProjectObservationResponseMetadata(metadata) {
 	const response = metadata?.project_observation_response;
-	if (!isRecord$8(response) || response.protocol !== "nextclaw.project/v1" || typeof response.requestId !== "string" || response.decision !== "confirmed" && response.decision !== "rejected") return null;
+	if (!isRecord$7(response) || response.protocol !== "nextclaw.project/v1" || typeof response.requestId !== "string" || response.decision !== "confirmed" && response.decision !== "rejected") return null;
 	return {
 		protocol: PROJECT_OBSERVATION_PROTOCOL,
 		requestId: response.requestId,
@@ -22046,7 +23066,7 @@ function deduplicateNcpAgentSessionTailMessages(messages) {
 function isNcpAgentSessionMessageProjectionMeta(value, sessionId) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
 	const meta = value;
-	return meta.version === 7 && meta.sessionId === sessionId && Number.isSafeInteger(meta.total) && Number.isSafeInteger(meta.projectedJournalOffset) && Number.isSafeInteger(meta.dataBytes) && (meta.activeMessageId === null || typeof meta.activeMessageId === "string") && Array.isArray(meta.pendingCompactionMessageIds) && meta.pendingCompactionMessageIds.every((id) => typeof id === "string") && (meta.contextWindow === null || isRecord$7(meta.contextWindow));
+	return meta.version === 7 && meta.sessionId === sessionId && Number.isSafeInteger(meta.total) && Number.isSafeInteger(meta.projectedJournalOffset) && Number.isSafeInteger(meta.dataBytes) && (meta.activeMessageId === null || typeof meta.activeMessageId === "string") && Array.isArray(meta.pendingCompactionMessageIds) && meta.pendingCompactionMessageIds.every((id) => typeof id === "string") && (meta.contextWindow === null || isRecord$6(meta.contextWindow));
 }
 function readActiveAssistantMessageId(messages) {
 	for (let index = messages.length - 1; index >= 0; index -= 1) {
@@ -22069,12 +23089,12 @@ function mergePendingCompactionMessageIds(current, messages) {
 	}
 	return pending;
 }
-function isRecord$7(value) {
+function isRecord$6(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function readCompactionStatus(message) {
 	const checkpoint = message.metadata?.checkpoint;
-	if (message.metadata?.nextclaw_timeline_kind !== "context_compaction" || !isRecord$7(checkpoint)) return null;
+	if (message.metadata?.nextclaw_timeline_kind !== "context_compaction" || !isRecord$6(checkpoint)) return null;
 	return typeof checkpoint.status === "string" ? checkpoint.status : null;
 }
 //#endregion
@@ -22582,151 +23602,6 @@ async function readLegacyRecords(journalDir, diagnostics) {
 	return /* @__PURE__ */ new Map();
 }
 //#endregion
-//#region src/stores/ncp-session-catalog-sqlite-driver.store.ts
-const require = createRequire(import.meta.url);
-const portableDatabases = /* @__PURE__ */ new Map();
-async function openSessionCatalogSqliteDatabase(databasePath) {
-	try {
-		return new (require("node:sqlite")).DatabaseSync(databasePath);
-	} catch (error) {
-		if (!isMissingNodeSqlite(error)) throw error;
-		return await openPortableDatabase(databasePath);
-	}
-}
-function runSessionCatalogSqliteTransaction(database, operation, mode = "DEFERRED") {
-	database.exec(`BEGIN ${mode}`);
-	try {
-		const result = operation();
-		database.exec("COMMIT");
-		return result;
-	} catch (error) {
-		database.exec("ROLLBACK");
-		throw error;
-	}
-}
-function isMissingNodeSqlite(error) {
-	const code = typeof error === "object" && error !== null ? error.code : void 0;
-	return code === "ERR_UNKNOWN_BUILTIN_MODULE" || code === "MODULE_NOT_FOUND";
-}
-async function openPortableDatabase(databasePath) {
-	const existing = portableDatabases.get(databasePath);
-	if (existing) return (await existing).acquire();
-	const opening = createPortableDatabase(databasePath).catch((error) => {
-		portableDatabases.delete(databasePath);
-		throw error;
-	});
-	portableDatabases.set(databasePath, opening);
-	return (await opening).acquire();
-}
-async function createPortableDatabase(databasePath) {
-	const initialize = (await import("sql.js")).default;
-	const sqlite = await initialize({ locateFile: (file) => require.resolve(`sql.js/dist/${file}`) });
-	return new PortableSessionCatalogSqliteDatabase(databasePath, existsSync(databasePath) ? new sqlite.Database(readFileSync(databasePath)) : new sqlite.Database());
-}
-var PortableSessionCatalogSqliteDatabase = class {
-	inTransaction = false;
-	dirty = false;
-	leaseCount = 0;
-	constructor(databasePath, database) {
-		this.databasePath = databasePath;
-		this.database = database;
-	}
-	acquire = () => {
-		this.leaseCount += 1;
-		return new PortableSessionCatalogSqliteLease(this);
-	};
-	exec = (sql) => {
-		const command = sql.trim().toUpperCase();
-		this.database.run(sql);
-		if (command.startsWith("BEGIN")) {
-			this.inTransaction = true;
-			return;
-		}
-		if (command.startsWith("ROLLBACK")) {
-			this.inTransaction = false;
-			this.dirty = false;
-			return;
-		}
-		if (command.startsWith("COMMIT")) {
-			this.inTransaction = false;
-			this.persistIfDirty();
-			return;
-		}
-		if (!command.startsWith("PRAGMA")) this.markDirty();
-	};
-	prepare = (sql) => new PortableSessionCatalogSqliteStatement(this, sql);
-	release = () => {
-		this.leaseCount -= 1;
-		if (this.leaseCount > 0) return;
-		this.persistIfDirty();
-		this.database.close();
-		portableDatabases.delete(this.databasePath);
-	};
-	run = (sql, params) => {
-		this.database.run(sql, normalizeParams(params));
-		this.markDirty();
-	};
-	readRows = (sql, params) => {
-		const statement = this.database.prepare(sql);
-		try {
-			bindStatement(statement, params);
-			const rows = [];
-			while (statement.step()) rows.push(statement.getAsObject());
-			return rows;
-		} finally {
-			statement.free();
-		}
-	};
-	markDirty = () => {
-		this.dirty = true;
-		if (!this.inTransaction) this.persistIfDirty();
-	};
-	persistIfDirty = () => {
-		if (!this.dirty) return;
-		const temporaryPath = `${this.databasePath}.tmp`;
-		writeFileSync(temporaryPath, this.database.export());
-		renameSync(temporaryPath, this.databasePath);
-		this.dirty = false;
-	};
-};
-var PortableSessionCatalogSqliteLease = class {
-	closed = false;
-	constructor(owner) {
-		this.owner = owner;
-	}
-	close = () => {
-		if (this.closed) return;
-		this.closed = true;
-		this.owner.release();
-	};
-	exec = (sql) => this.owner.exec(sql);
-	prepare = (sql) => this.owner.prepare(sql);
-};
-var PortableSessionCatalogSqliteStatement = class {
-	constructor(database, sql) {
-		this.database = database;
-		this.sql = sql;
-	}
-	all = (...params) => this.database.readRows(this.sql, params);
-	get = (...params) => this.all(...params)[0];
-	run = (...params) => {
-		this.database.run(this.sql, params);
-		return {};
-	};
-};
-function bindStatement(statement, params) {
-	const normalized = normalizeParams(params);
-	if (Array.isArray(normalized) && normalized.length === 0) return;
-	statement.bind(normalized);
-}
-function normalizeParams(params) {
-	if (params.length !== 1 || !isRecord$6(params[0])) return params;
-	return Object.fromEntries(Object.entries(params[0]).map(([key, value]) => [`@${key}`, value]));
-}
-function isRecord$6(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
 //#region src/stores/ncp-agent-session-summary-index.store.ts
 const SQLITE_DATABASE_FILE = ".ncp-agent-session-catalog.sqlite";
 const CATALOG_SCHEMA_VERSION = 1;
@@ -22866,7 +23741,7 @@ var NcpAgentSessionSummaryIndexStore = class {
 		await this.ensureReady();
 		const normalizedSessionId = normalizeNcpSessionId(sessionId);
 		const deletedAt = (/* @__PURE__ */ new Date()).toISOString();
-		runSessionCatalogSqliteTransaction(this.db(), () => {
+		runSqliteTransaction(this.db(), () => {
 			if (this.db().prepare("SELECT session_id FROM sessions WHERE session_id = ? LIMIT 1").get(normalizedSessionId)) {
 				this.db().prepare("UPDATE sessions SET deleted_at = ? WHERE session_id = ?").run(deletedAt, normalizedSessionId);
 				return;
@@ -22891,7 +23766,7 @@ var NcpAgentSessionSummaryIndexStore = class {
 	};
 	initializeCatalog = async () => {
 		await mkdir(this.journalDir, { recursive: true });
-		this.database = await openSessionCatalogSqliteDatabase(resolve(this.journalDir, SQLITE_DATABASE_FILE));
+		this.database = await openSqliteDatabase(resolve(this.journalDir, SQLITE_DATABASE_FILE));
 		this.database.exec(`
       PRAGMA busy_timeout = 10000;
       PRAGMA journal_mode = WAL;
@@ -22931,7 +23806,7 @@ var NcpAgentSessionSummaryIndexStore = class {
 			loadSession: (sessionId) => this.loadSession(sessionId),
 			loadSessionSummary: this.loadSessionSummary
 		});
-		runSessionCatalogSqliteTransaction(this.db(), () => {
+		runSqliteTransaction(this.db(), () => {
 			if (this.db().prepare("SELECT value FROM storage_meta WHERE key = ? LIMIT 1").get(MIGRATION_STATUS_KEY)?.value === MIGRATION_COMPLETE) {
 				this.reconcileRecords(scan.records);
 				return;
@@ -25786,12 +26661,234 @@ var ProjectsCreateTool = class {
 	};
 };
 //#endregion
+//#region src/tools/project-work.tools.ts
+function requiredString$1(value, key) {
+	if (typeof value !== "string" || !value.trim()) throw new Error(`${key} must be a non-empty string.`);
+	return value.trim();
+}
+function optionalString$1(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function optionalBoolean(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function optionalNumber(value) {
+	return typeof value === "number" && Number.isInteger(value) ? value : void 0;
+}
+function agentActor(context) {
+	return {
+		kind: "agent",
+		...context.agentId ? { id: context.agentId } : {},
+		sessionId: context.sessionId
+	};
+}
+var ProjectWorkListTool = class {
+	name = "project_work_list";
+	description = "List persistent work items and custom states for the current project.";
+	parameters = {
+		type: "object",
+		properties: { include_deleted: {
+			type: "boolean",
+			description: "Include deleted work items."
+		} },
+		additionalProperties: false
+	};
+	constructor(work, context) {
+		this.work = work;
+		this.context = context;
+	}
+	execute = async (args) => {
+		const params = normalizeToolParams(args);
+		return JSON.stringify(await this.work.list(this.context.projectId, optionalBoolean(params.include_deleted) ?? false), null, 2);
+	};
+};
+var ProjectWorkGetTool = class {
+	name = "project_work_get";
+	description = "Get one current-project work item with artifact links and recent immutable activity.";
+	parameters = {
+		type: "object",
+		properties: {
+			id: {
+				type: "string",
+				description: "Work item id."
+			},
+			activity_limit: {
+				type: "integer",
+				minimum: 1,
+				maximum: 100,
+				description: "Recent activity entries. Defaults to 20."
+			}
+		},
+		required: ["id"],
+		additionalProperties: false
+	};
+	constructor(work, context) {
+		this.work = work;
+		this.context = context;
+	}
+	execute = async (args) => {
+		const params = normalizeToolParams(args);
+		const id = requiredString$1(params.id, "id");
+		const [item, activity] = await Promise.all([this.work.get(this.context.projectId, id), this.work.listActivities(this.context.projectId, id, { limit: optionalNumber(params.activity_limit) ?? 20 })]);
+		return JSON.stringify({
+			item,
+			activity
+		}, null, 2);
+	};
+};
+var ProjectWorkCreateTool = class {
+	name = "project_work_create";
+	description = "Create a persistent work item in the current project.";
+	parameters = {
+		type: "object",
+		properties: {
+			title: {
+				type: "string",
+				description: "Concise work item title."
+			},
+			description: {
+				type: "string",
+				description: "Optional durable context and acceptance notes."
+			},
+			state_id: {
+				type: "string",
+				description: "Optional custom state id. The project default is used when omitted."
+			},
+			attention: {
+				type: "string",
+				enum: [
+					"none",
+					"blocked",
+					"awaiting-user"
+				]
+			}
+		},
+		required: ["title"],
+		additionalProperties: false
+	};
+	constructor(work, context) {
+		this.work = work;
+		this.context = context;
+	}
+	execute = async (args) => {
+		const params = normalizeToolParams(args);
+		return JSON.stringify(await this.work.create(this.context.projectId, {
+			title: requiredString$1(params.title, "title"),
+			...optionalString$1(params.description) ? { description: optionalString$1(params.description) } : {},
+			...optionalString$1(params.state_id) ? { stateId: optionalString$1(params.state_id) } : {},
+			...optionalString$1(params.attention) ? { attention: optionalString$1(params.attention) } : {}
+		}, agentActor(this.context)), null, 2);
+	};
+};
+var ProjectWorkUpdateTool = class {
+	name = "project_work_update";
+	description = "Update, soft-delete, or restore a current-project work item, or add/remove its artifact links. Status changes use state_id; there is no separate start tool.";
+	parameters = {
+		type: "object",
+		properties: {
+			id: {
+				type: "string",
+				description: "Work item id."
+			},
+			title: { type: "string" },
+			description: { type: "string" },
+			state_id: { type: "string" },
+			attention: {
+				type: "string",
+				enum: [
+					"none",
+					"blocked",
+					"awaiting-user"
+				]
+			},
+			expected_version: {
+				type: "integer",
+				minimum: 1
+			},
+			deleted: {
+				type: "boolean",
+				description: "True to soft-delete the item; false to restore it."
+			},
+			add_artifact: {
+				type: "object",
+				properties: {
+					path: { type: "string" },
+					label: { type: "string" }
+				},
+				required: ["path"],
+				additionalProperties: false
+			},
+			remove_artifact_id: { type: "string" }
+		},
+		required: ["id"],
+		additionalProperties: false
+	};
+	constructor(work, context) {
+		this.work = work;
+		this.context = context;
+	}
+	execute = async (args) => {
+		const params = normalizeToolParams(args);
+		const id = requiredString$1(params.id, "id");
+		const actor = agentActor(this.context);
+		const patch = {
+			...params.title !== void 0 ? { title: requiredString$1(params.title, "title") } : {},
+			...typeof params.description === "string" ? { description: params.description } : {},
+			...optionalString$1(params.state_id) ? { stateId: optionalString$1(params.state_id) } : {},
+			...optionalString$1(params.attention) ? { attention: optionalString$1(params.attention) } : {},
+			...optionalNumber(params.expected_version) ? { expectedVersion: optionalNumber(params.expected_version) } : {}
+		};
+		if (Object.keys(patch).length > 0) await this.work.update(this.context.projectId, id, patch, actor);
+		const deleted = optionalBoolean(params.deleted);
+		if (deleted !== void 0) await (deleted ? this.work.delete(this.context.projectId, id, actor) : this.work.restore(this.context.projectId, id, actor));
+		if (params.add_artifact && typeof params.add_artifact === "object" && !Array.isArray(params.add_artifact)) {
+			const artifact = params.add_artifact;
+			await this.work.linkArtifact({
+				projectId: this.context.projectId,
+				workItemId: id,
+				path: requiredString$1(artifact.path, "add_artifact.path"),
+				...optionalString$1(artifact.label) ? { label: optionalString$1(artifact.label) } : {},
+				actor
+			});
+		}
+		const removeArtifactId = optionalString$1(params.remove_artifact_id);
+		if (removeArtifactId) await this.work.unlinkArtifact({
+			projectId: this.context.projectId,
+			workItemId: id,
+			artifactLinkId: removeArtifactId,
+			actor
+		});
+		return JSON.stringify(await this.work.get(this.context.projectId, id), null, 2);
+	};
+};
+//#endregion
 //#region src/contributions/tool-provider/providers/project-tool.provider.ts
 var ProjectToolProvider = class {
-	constructor(projectManager) {
+	constructor(runContext, projectManager, projectWork) {
+		this.runContext = runContext;
 		this.projectManager = projectManager;
+		this.projectWork = projectWork;
 	}
-	provide = (_request) => [new ProjectsListTool(this.projectManager), new ProjectsCreateTool(this.projectManager)];
+	provide = async (request) => {
+		const globalTools = [new ProjectsListTool(this.projectManager), new ProjectsCreateTool(this.projectManager)];
+		const resolved = await this.runContext.resolve(request);
+		const projectId = readProjectId(resolved.session?.metadata);
+		const projectRoot = readProjectRoot(resolved.session?.metadata);
+		const project = projectId ? await this.projectManager.getProjectById(projectId) : projectRoot ? await this.projectManager.getRegisteredProject(projectRoot) : null;
+		if (!project || !resolved.sessionId) return globalTools;
+		const context = {
+			projectId: project.id,
+			sessionId: resolved.sessionId,
+			...resolved.session?.agentId ? { agentId: resolved.session.agentId } : {}
+		};
+		return [
+			...globalTools,
+			new ProjectWorkListTool(this.projectWork, context),
+			new ProjectWorkGetTool(this.projectWork, context),
+			new ProjectWorkCreateTool(this.projectWork, context),
+			new ProjectWorkUpdateTool(this.projectWork, context)
+		];
+	};
 };
 //#endregion
 //#region src/tools/session-history.tools.ts
@@ -27628,7 +28725,7 @@ var ToolProviderContribution = class extends Contribution$1 {
 			new DesktopToolProvider(runContextService, this.kernel.extensions.getDesktopHost()),
 			new CoreToolProvider(runContextService, this.kernel.getGatewayController),
 			new MessagingToolProvider(runContextService, this.kernel.channels, this.kernel.automation, this.kernel.extensions),
-			new ProjectToolProvider(this.kernel.projectManager),
+			new ProjectToolProvider(runContextService, this.kernel.projectManager, this.kernel.projectWorkManager),
 			new SessionToolProvider(runContextService, this.kernel.sessionManager, this.kernel.sessionRequests, this.kernel.sessionSearch),
 			new AssetToolProvider(this.kernel.assetStore),
 			new ServiceActionToolProvider(runContextService, this.kernel.serviceAppManager),
@@ -27668,6 +28765,7 @@ function createKernelServiceAppManagers(params) {
 		appHomeDirectory,
 		configManager,
 		listPackageComponentSources: appPackageManager.listActiveComponentSources,
+		assertDocumentAccess: appPackageManager.assertDocumentAccess,
 		capabilityGrantManager,
 		hasAgent,
 		providerManager,
@@ -27724,16 +28822,26 @@ function createPortableRuntimeAcceptanceServices(params) {
 	};
 }
 function createKernelSessionManagers(params) {
-	const { agentContextWindowManager, agentManager, configManager, eventBus, ingress, observationStorePath, projectStorePath, sessionsDir } = params;
+	const { agentContextWindowManager, agentManager, configManager, eventBus, ingress, observationStorePath, projectStorePath, projectWorkStorePath, sessionsDir } = params;
 	const sessionSearch = new SessionSearchService({
 		databasePath: resolve(getDataDir(), "session-search.db"),
 		sessionsDir
 	});
 	const journalStore = new NcpAgentSessionJournalStore(resolve(sessionsDir, ".ncp-agent-journal"));
+	const projectWorkOwner = { current: null };
 	const projectManager = new ProjectManager({
 		storePath: projectStorePath,
-		getDefaultWorkspacePath: () => getWorkspacePathFromConfig(configManager.config)
+		getDefaultWorkspacePath: () => getWorkspacePathFromConfig(configManager.config),
+		onProjectRegistered: async (project) => {
+			await projectWorkOwner.current?.ensureProject(project.id);
+		}
 	});
+	const projectWorkManager = new ProjectWorkManager({
+		databasePath: projectWorkStorePath,
+		eventBus,
+		projectManager
+	});
+	projectWorkOwner.current = projectWorkManager;
 	const observationOwner = { current: null };
 	const sessionManager = new SessionManager({
 		agentContextWindowManager,
@@ -27766,6 +28874,7 @@ function createKernelSessionManagers(params) {
 		observations,
 		projectManager,
 		projectObservation,
+		projectWorkManager,
 		sessionManager,
 		sessionSearch
 	};
@@ -27794,6 +28903,10 @@ function installKernelAppPackageRuntimeHooks(params) {
 			panelAppManager.deactivatePackageComponents(sources);
 			await serviceAppManager.deactivatePackageComponents(sources);
 		},
+		prepareCapabilityChange: async (sources) => await serviceAppManager.preparePackageComponentDeactivation(sources),
+		afterCapabilityChange: async (sources) => {
+			await serviceAppManager.activatePackageComponents(sources);
+		},
 		beforeUninstall: async (sources) => {
 			const rollbacks = [];
 			try {
@@ -27862,6 +28975,7 @@ var NextclawKernel = class {
 	preferenceManager;
 	projectManager;
 	projectObservation;
+	projectWorkManager;
 	serviceAppManager;
 	extensions;
 	agentRuntimeManager = new AgentRuntimeManager();
@@ -27907,7 +29021,7 @@ var NextclawKernel = class {
 			homeDir: options.homeDir
 		});
 		this.capabilityGrantLegacyMigration = this.createCapabilityGrantLegacyMigration(options);
-		({journalStore: this.ncpAgentSessionJournalStore, observations: this.observations, projectManager: this.projectManager, projectObservation: this.projectObservation, sessionManager: this.sessionManager, sessionSearch: this.sessionSearch} = createKernelSessionManagers({
+		({journalStore: this.ncpAgentSessionJournalStore, observations: this.observations, projectManager: this.projectManager, projectObservation: this.projectObservation, projectWorkManager: this.projectWorkManager, sessionManager: this.sessionManager, sessionSearch: this.sessionSearch} = createKernelSessionManagers({
 			agentContextWindowManager: this.agentContextWindowManager,
 			agentManager: this.agents,
 			configManager: this.configManager,
@@ -27915,6 +29029,7 @@ var NextclawKernel = class {
 			ingress: this.ingress,
 			observationStorePath: resolveKernelObservationStorePath(options),
 			projectStorePath: resolveKernelProjectStorePath(options),
+			projectWorkStorePath: resolveKernelProjectWorkStorePath(options),
 			sessionsDir
 		}));
 		this.inboxDeliveryManager = new InboxDeliveryManager({
@@ -28016,6 +29131,7 @@ var NextclawKernel = class {
 		this.providerModelCatalog.start();
 		await this.projectManager.migrateLegacyProjects();
 		await this.projectManager.importSessionProjects((await this.sessionManager.listSessions()).map((session) => readProjectRoot(session.metadata)));
+		await this.projectWorkManager.initialize();
 		await this.sessionManager.start();
 		for (const contribution of this.contributions) await contribution.start();
 		this.agentRunRequestManager.start();
@@ -28035,6 +29151,7 @@ var NextclawKernel = class {
 		await this.mcpManager.dispose();
 		await this.serviceAppManager.dispose();
 		await this.sessionSearch.dispose();
+		this.projectWorkManager.dispose();
 	};
 };
 //#endregion
@@ -29177,6 +30294,6 @@ function resolveLegacyEventType(message) {
 	return `message.${role || "other"}`;
 }
 //#endregion
-export { AUTOMATIC_UPDATE_CHECK_INTERVAL_MS, AccessManager, AgentManager, AgentRunClient, AppDataError, AppDataManager, AppPackageError, AppPackageManager, AutomationManager, BuiltinNarpRuntimeProviderService, CONTEXT_COMPACTION_CONTINUATION_TEXT, CONTEXT_COMPACTION_PROJECTION_KIND, CONTEXT_COMPACTION_PROJECTION_METADATA_KEY, CONTEXT_COMPACTION_SYSTEM_PREAMBLE, CONTEXT_COMPACTION_TIMELINE_KIND, CapabilityGrantLegacyMigrationService, CapabilityGrantManager, CapabilityGrantStore, ChannelManager, CommandRegistry, ConfigManager, ContextCompactionJournalRecoveryService, ContextCompactionPreflightService, Contribution, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DEFAULT_SERVICE_ACTION_RISK, DESKTOP_HOST_ACCESS, DESKTOP_HOST_PROTOCOL_VERSION, DesktopHostCapabilityManager, DesktopNodeReplService, DesktopSessionStateService, EventBus, ExtensionManager, FeatureControlsService, GatewayInboundProcessor, InboxDeliveryError, InboxDeliveryManager, Ingress, LlmProviderManager, LlmUsageManager, LlmUsageStore, MAX_INBOX_DELIVERY_CONTENT_LENGTH, McpManager, McpServiceAppRuntimeService, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NEXTCLAW_TIMELINE_KIND_METADATA_KEY, NcpAgentSessionJournalStore, NextclawHarness, NextclawHarnessError, NextclawKernel, ObservationManager, PANEL_APP_AGENT_CAPABILITIES, PORTABLE_RUNTIME_ACCEPTANCE_CONTRACT, PORTABLE_RUNTIME_ACCEPTANCE_CONTRACT_FINGERPRINT, PORTABLE_RUNTIME_ACCEPTANCE_LOCALES, PORTABLE_RUNTIME_ACCEPTANCE_PLATFORMS, PORTABLE_RUNTIME_ACCEPTANCE_PRESENTATION, PORTABLE_RUNTIME_ACCEPTANCE_REFERENCE_APP_ID, PROJECT_OBSERVATION_PROTOCOL, PROJECT_TEMPLATE_IDS, PROVIDER_MODEL_CATALOG_REFRESH_INTERVAL_MS, PanelAppAssetTokenService, PanelAppError, PanelAppManager, PortableRuntimeAcceptanceIdentityService, PortableRuntimeAcceptanceManager, PreferenceError, PreferenceManager, ProjectError, ProjectManager, ProjectObservationError, ProjectObservationService, ProviderManagerNcpLLMApi, ProviderModelCatalogManager, SERVICE_APP_MANIFEST_FILE_NAME, ServiceAppAiCapabilityService, ServiceAppError, ServiceAppJobJournalService, ServiceAppManager, ServiceAppResidentEventInboxService, ServiceAppRuntimeService, SessionContextCompactionError, SessionContextCompactionManager, SessionManager, SessionMessageCursorError, SessionRequestManager, SessionSettingsError, SkillManager, SystemObjectReferenceError, SystemObjectReferenceManager, UnavailableDesktopHost, UpdateManifestReader, VerificationRecordService, assertObservationJsonValue, assertObservationPredicate, buildAgentRunSendPayload, buildContextCompactionModelProjection, buildContextCompactionTimelineNcpMessage, buildLlmUsageSummary, buildLocalizedTextMap, buildNextclawNcpRunContext, buildObservationEventModelMessage, buildServiceActionId, buildSessionRequestCompletionMessage, capabilityGrantCovers, createAgentRuntimeSessionRequestDispatcher, createAgentRuntimeSessionRequestSourceNotifier, createAssetTools, createCapabilityDeclarationFingerprint, createContextCompactionMessageId, createContextWindowSignature, createCronJobSystemObjectProvider, createDesktopHostError, createInboxDeliverySystemObjectProvider, createLlmUsageRecord, createPanelAppAgentGrantRequest, createPanelAppClientGrantRequest, createServiceActionGrantRequest, createServiceAppAgentSlotGrantRequest, createServiceAppModelSlotGrantRequest, createTypedKey, describeAgentRuntimeSessionTypes, dispatchAgentRuntimeSessionRequest, dispatchChannelReplyRoute, dispatchPromptOverNcp, dispatchPromptOverNcpResult, evaluateObservationEventAdmission, evaluatePortableRuntimeAcceptance, evaluatePortableRuntimeAcceptanceArtifact, eventKeys, getAutomaticUpdateCheckDelay, getCapabilityGrantKey, getServiceActionName, getServiceAppManifestPath, getUiContentParamsBootstrapScript, getUnsignedUpdateManifest, hasLlmUsageTelemetry, ingressKeys, injectUiContentParamsBootstrap, isAppDataError, isAppPackageError, isContextCompactionProjectionMessage, isContextCompactionTimelineMessage, isContextWindowSnapshot, isInboxDeliveryError, isPanelAppAgentCapability, isPanelAppError, isPreferenceError, isProjectError, isProjectObservationError, isReplyCapableChannel, isServiceAppError, isSessionContextCompactionError, isSessionMessageCursorError, isSessionSettingsError, isSystemObjectReferenceError, listExtensionChannelIds, listServiceAppManifestActions, matchesCapabilityGrantFilter, matchesObservationPredicate, mergeServiceAppRuntimeActions, normalizeAgentRuntimeSessionTypeIcon, normalizeCapabilityGrantRequest, normalizeLlmUsageModel, normalizeOptionalString, normalizePortableRuntimeEnvironment, parseObservationDuration, parsePortableRuntimeAcceptanceEvidenceArtifact, parseServiceAppManifest, parseSkillFrontmatter, presentPortableRuntimeAcceptanceDefinition, readContextCompactionCheckpoint, readContextWindowEventSessionId, readJsonPointer, readLatestContextCompactionCheckpoint, readLearningLoopRuntimeConfig, readMetadataModel, readMetadataThinking, readServiceActionTargetId, readServiceAppManifest, readServiceAppSlotTarget, resolveAgentRuntimeEntries, resolveAutomaticUpdateCheckIntervalMs, resolveChannelReplyRoute, resolveEffectiveModel, resolveLegacyEventType, resolvePortableRuntimeAcceptanceLocale, resolveSessionChannelContext, runGatewayInboundLoop, runNextclawTask, sanitizeLlmUsage, serializeContextTail, serializeUnsignedUpdateManifest, shouldRefreshContextWindowDuringStream, shouldRefreshContextWindowImmediately, startPromptOverNcpExecution, stripSkillFrontmatter, syncSessionThinkingPreference, toBoundedJson, toNcpMessages, waitForAgentRuntimeSessionReply };
+export { AUTOMATIC_UPDATE_CHECK_INTERVAL_MS, AccessManager, AgentManager, AgentRunClient, AppDataError, AppDataManager, AppPackageError, AppPackageManager, AutomationManager, BuiltinNarpRuntimeProviderService, CONTEXT_COMPACTION_CONTINUATION_TEXT, CONTEXT_COMPACTION_PROJECTION_KIND, CONTEXT_COMPACTION_PROJECTION_METADATA_KEY, CONTEXT_COMPACTION_SYSTEM_PREAMBLE, CONTEXT_COMPACTION_TIMELINE_KIND, CapabilityGrantLegacyMigrationService, CapabilityGrantManager, CapabilityGrantStore, ChannelManager, CommandRegistry, ConfigManager, ContextCompactionJournalRecoveryService, ContextCompactionPreflightService, Contribution, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DEFAULT_SERVICE_ACTION_RISK, DESKTOP_HOST_ACCESS, DESKTOP_HOST_PROTOCOL_VERSION, DesktopHostCapabilityManager, DesktopNodeReplService, DesktopSessionStateService, EventBus, ExtensionManager, FeatureControlsService, GatewayInboundProcessor, InboxDeliveryError, InboxDeliveryManager, Ingress, LlmProviderManager, LlmUsageManager, LlmUsageStore, MAX_INBOX_DELIVERY_CONTENT_LENGTH, McpManager, McpServiceAppRuntimeService, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NEXTCLAW_TIMELINE_KIND_METADATA_KEY, NcpAgentSessionJournalStore, NextclawHarness, NextclawHarnessError, NextclawKernel, ObservationManager, PANEL_APP_AGENT_CAPABILITIES, PORTABLE_RUNTIME_ACCEPTANCE_CONTRACT, PORTABLE_RUNTIME_ACCEPTANCE_CONTRACT_FINGERPRINT, PORTABLE_RUNTIME_ACCEPTANCE_LOCALES, PORTABLE_RUNTIME_ACCEPTANCE_PLATFORMS, PORTABLE_RUNTIME_ACCEPTANCE_PRESENTATION, PORTABLE_RUNTIME_ACCEPTANCE_REFERENCE_APP_ID, PROJECT_OBSERVATION_PROTOCOL, PROJECT_TEMPLATE_IDS, PROJECT_WORK_ATTENTION_VALUES, PROJECT_WORK_STATE_CATEGORIES, PROVIDER_MODEL_CATALOG_REFRESH_INTERVAL_MS, PanelAppAssetTokenService, PanelAppError, PanelAppManager, PortableRuntimeAcceptanceIdentityService, PortableRuntimeAcceptanceManager, PreferenceError, PreferenceManager, ProjectError, ProjectManager, ProjectObservationError, ProjectObservationService, ProjectWorkError, ProjectWorkManager, ProviderManagerNcpLLMApi, ProviderModelCatalogManager, SERVICE_APP_MANIFEST_FILE_NAME, ServiceAppAiCapabilityService, ServiceAppError, ServiceAppJobJournalService, ServiceAppManager, ServiceAppResidentEventInboxService, ServiceAppRuntimeService, SessionContextCompactionError, SessionContextCompactionManager, SessionManager, SessionMessageCursorError, SessionRequestManager, SessionSettingsError, SkillManager, SystemObjectReferenceError, SystemObjectReferenceManager, UnavailableDesktopHost, UpdateManifestReader, VerificationRecordService, assertObservationJsonValue, assertObservationPredicate, buildAgentRunSendPayload, buildContextCompactionModelProjection, buildContextCompactionTimelineNcpMessage, buildLlmUsageSummary, buildLocalizedTextMap, buildNextclawNcpRunContext, buildObservationEventModelMessage, buildServiceActionId, buildSessionRequestCompletionMessage, capabilityGrantCovers, createAgentRuntimeSessionRequestDispatcher, createAgentRuntimeSessionRequestSourceNotifier, createAssetTools, createCapabilityDeclarationFingerprint, createContextCompactionMessageId, createContextWindowSignature, createCronJobSystemObjectProvider, createDesktopHostError, createInboxDeliverySystemObjectProvider, createLlmUsageRecord, createPanelAppAgentGrantRequest, createPanelAppClientGrantRequest, createServiceActionGrantRequest, createServiceAppAgentSlotGrantRequest, createServiceAppModelSlotGrantRequest, createTypedKey, describeAgentRuntimeSessionTypes, dispatchAgentRuntimeSessionRequest, dispatchChannelReplyRoute, dispatchPromptOverNcp, dispatchPromptOverNcpResult, evaluateObservationEventAdmission, evaluatePortableRuntimeAcceptance, evaluatePortableRuntimeAcceptanceArtifact, eventKeys, getAutomaticUpdateCheckDelay, getCapabilityGrantKey, getServiceActionName, getServiceAppManifestPath, getUiContentParamsBootstrapScript, getUnsignedUpdateManifest, hasLlmUsageTelemetry, ingressKeys, injectUiContentParamsBootstrap, isAppDataError, isAppPackageError, isContextCompactionProjectionMessage, isContextCompactionTimelineMessage, isContextWindowSnapshot, isInboxDeliveryError, isPanelAppAgentCapability, isPanelAppError, isPreferenceError, isProjectError, isProjectObservationError, isProjectWorkError, isReplyCapableChannel, isServiceAppError, isSessionContextCompactionError, isSessionMessageCursorError, isSessionSettingsError, isSystemObjectReferenceError, listExtensionChannelIds, listServiceAppManifestActions, matchesCapabilityGrantFilter, matchesObservationPredicate, mergeServiceAppRuntimeActions, normalizeAgentRuntimeSessionTypeIcon, normalizeCapabilityGrantRequest, normalizeLlmUsageModel, normalizeOptionalString, normalizePortableRuntimeEnvironment, parseObservationDuration, parsePortableRuntimeAcceptanceEvidenceArtifact, parseServiceAppManifest, parseSkillFrontmatter, presentPortableRuntimeAcceptanceDefinition, readContextCompactionCheckpoint, readContextWindowEventSessionId, readJsonPointer, readLatestContextCompactionCheckpoint, readLearningLoopRuntimeConfig, readMetadataModel, readMetadataThinking, readServiceActionTargetId, readServiceAppManifest, readServiceAppSlotTarget, resolveAgentRuntimeEntries, resolveAutomaticUpdateCheckIntervalMs, resolveChannelReplyRoute, resolveEffectiveModel, resolveLegacyEventType, resolvePortableRuntimeAcceptanceLocale, resolveSessionChannelContext, runGatewayInboundLoop, runNextclawTask, sanitizeLlmUsage, serializeContextTail, serializeUnsignedUpdateManifest, shouldRefreshContextWindowDuringStream, shouldRefreshContextWindowImmediately, startPromptOverNcpExecution, stripSkillFrontmatter, syncSessionThinkingPreference, toBoundedJson, toNcpMessages, waitForAgentRuntimeSessionReply };
 
 //# sourceMappingURL=index.js.map