@nextclaw/kernel 0.15.1 → 0.15.2

package/dist/index.js

@@ -4404,7 +4404,7 @@ var AppPackageDependencyCoordinator = class {
 	});
 	resolveStoredProviderIds = async (target) => await this.dependencyService.resolveStoredProviderIds(target);
 	listBindings = async (target) => await this.dependencyService.listBindings(target);
-	listActiveComponentSourcesWithDiagnostics = async () => {
+	loadActiveComponentSourcesWithDiagnostics = async () => {
 		const records = await this.params.registryService.listApps();
 		const results = await Promise.all(records.filter((record) => record.enabled).map(async (record) => {
 			try {
@@ -4542,6 +4542,54 @@ var AppPackageDependencyCoordinator = class {
 	};
 };
 //#endregion
+//#region src/services/app-package-component-catalog.service.ts
+const EMPTY_COMPONENT_CATALOG = {
+	sources: [],
+	unavailablePackages: []
+};
+/**
+* Owns the verified projection of active package components.
+*
+* Expensive package integrity checks happen while refreshing this catalog at
+* lifecycle boundaries. Product reads consume the last complete snapshot and
+* never trigger a package-tree scan after initialization.
+*/
+var AppPackageComponentCatalogService = class {
+	snapshot = EMPTY_COMPONENT_CATALOG;
+	requestedRevision = 0;
+	appliedRevision = 0;
+	refreshPromise;
+	constructor(load) {
+		this.load = load;
+	}
+	read = async () => {
+		if (this.appliedRevision === 0) await this.refresh();
+		return cloneCatalog(this.snapshot);
+	};
+	refresh = async () => {
+		this.requestedRevision += 1;
+		this.refreshPromise ??= this.runRefreshLoop();
+		await this.refreshPromise;
+	};
+	runRefreshLoop = async () => {
+		try {
+			while (this.appliedRevision < this.requestedRevision) {
+				const targetRevision = this.requestedRevision;
+				this.snapshot = cloneCatalog(await this.load());
+				this.appliedRevision = targetRevision;
+			}
+		} finally {
+			this.refreshPromise = void 0;
+		}
+	};
+};
+function cloneCatalog(catalog) {
+	return {
+		sources: catalog.sources.map((source) => ({ ...source })),
+		unavailablePackages: catalog.unavailablePackages.map((diagnostic) => ({ ...diagnostic }))
+	};
+}
+//#endregion
 //#region src/services/app-package-document-access.service.ts
 var AppPackageDocumentAccessService = class {
 	constructor(params) {
@@ -4709,6 +4757,7 @@ var AppPackageManager = class {
 	hostTargetService = new AppPackageHostTargetService();
 	presentationService = new AppPackagePresentationService();
 	dependencyCoordinator;
+	componentCatalog;
 	runtimeActivationService = new AppPackageRuntimeActivationService();
 	registryService;
 	grantService;
@@ -4736,6 +4785,7 @@ var AppPackageManager = class {
 			listCapabilityProviders: async () => await this.runtimeHooks.listCapabilityProviders(),
 			resolveSecurity: this.resolveSecurity
 		});
+		this.componentCatalog = new AppPackageComponentCatalogService(this.dependencyCoordinator.loadActiveComponentSourcesWithDiagnostics);
 		this.readinessManager = new AppPackageReadinessManager({
 			manifestService: this.manifestService,
 			installationService: this.installationService,
@@ -4759,7 +4809,10 @@ var AppPackageManager = class {
 			...hooks
 		};
 	};
-	start = async () => await this.ensureBuiltInPackages();
+	start = async () => {
+		await this.ensureBuiltInPackages();
+		await this.componentCatalog.refresh();
+	};
 	listPackages = async (options = {}) => {
 		const [records, providers] = await Promise.all([this.registryService.listApps(), this.runtimeHooks.listCapabilityProviders()]);
 		const entries = (await Promise.all(records.map(async (record) => await this.installationService.withAppOperation(record.appId, async () => await this.readListedPackageView(record.appId, options.includeStorageUsage !== false, providers))))).filter((entry) => entry !== void 0);
@@ -4784,9 +4837,21 @@ var AppPackageManager = class {
 	};
 	inspectDependencies = async (appId) => await this.installationService.withAppOperation(appId, async () => await this.dependencyCoordinator.inspect(appId));
 	verifyDependencies = async (appId) => await this.installationService.withAppOperation(appId, async () => await this.dependencyCoordinator.verify(appId));
-	setupDependencies = async (appId) => await this.dependencyCoordinator.setup(appId);
-	bindDependency = async (appId, input) => await this.dependencyCoordinator.bind(appId, input);
-	unbindDependency = async (appId, input) => await this.dependencyCoordinator.unbind(appId, input);
+	setupDependencies = async (appId) => {
+		const result = await this.dependencyCoordinator.setup(appId);
+		await this.componentCatalog.refresh();
+		return result;
+	};
+	bindDependency = async (appId, input) => {
+		const result = await this.dependencyCoordinator.bind(appId, input);
+		await this.componentCatalog.refresh();
+		return result;
+	};
+	unbindDependency = async (appId, input) => {
+		const result = await this.dependencyCoordinator.unbind(appId, input);
+		await this.componentCatalog.refresh();
+		return result;
+	};
 	inspectSecrets = async (appId) => await this.installationService.withAppOperation(appId, async () => await this.readinessManager.inspectSecrets(await this.installationService.info(appId), false));
 	verifySecrets = async (appId) => await this.installationService.withAppOperation(appId, async () => await this.readinessManager.inspectSecrets(await this.installationService.info(appId), true));
 	bindSecret = async (appId, input) => await this.installationService.withAppOperation(appId, async () => {
@@ -4810,7 +4875,7 @@ var AppPackageManager = class {
 	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();
+	listActiveComponentSourcesWithDiagnostics = async () => await this.componentCatalog.read();
 	listOperations = async () => await this.operationManager.list();
 	startOperation = async (input) => {
 		await this.ensureBuiltInPackages();
@@ -4822,6 +4887,7 @@ var AppPackageManager = class {
 			onProgress
 		});
 		if (await this.isBuiltInAppId(result.appId)) await this.registryService.setBuiltInSuppressed(result.appId, false);
+		await this.componentCatalog.refresh();
 		return await this.getPackage(result.appId);
 	};
 	enable = async (appId) => {
@@ -4849,6 +4915,7 @@ var AppPackageManager = class {
 				});
 				throw error;
 			}
+			await this.componentCatalog.refresh();
 			return await this.getPackage(appId);
 		});
 	};
@@ -4859,6 +4926,7 @@ var AppPackageManager = class {
 			await this.dependencyCoordinator.assertNoEnabledDependents(app);
 			await this.runtimeHooks.beforeDeactivate(this.toComponentSources(app));
 			await this.installationService.setEnabled(appId, false);
+			await this.componentCatalog.refresh();
 			return await this.getPackage(appId);
 		});
 	};
@@ -4888,6 +4956,7 @@ var AppPackageManager = class {
 				}
 				activated = (await this.installationService.rollback(appId, result.version)).rolledBack;
 				if (current.enabled) await this.runtimeHooks.afterActivate(this.toComponentSources(candidate));
+				await this.componentCatalog.refresh();
 				return {
 					package: await this.getPackage(appId),
 					result
@@ -4932,6 +5001,7 @@ var AppPackageManager = class {
 				}
 				result = await this.installationService.rollback(appId, version);
 				if (current.enabled) await this.runtimeHooks.afterActivate(this.toComponentSources(candidate));
+				await this.componentCatalog.refresh();
 				return {
 					package: await this.getPackage(appId),
 					result
@@ -4957,7 +5027,9 @@ var AppPackageManager = class {
 			try {
 				const sources = this.toComponentSources(current);
 				rollbackRuntimeState = await this.runtimeHooks.beforeUninstall(sources) || void 0;
-				return await this.installationService.uninstall(appId, purgeData);
+				const result = await this.installationService.uninstall(appId, purgeData);
+				await this.componentCatalog.refresh();
+				return result;
 			} catch (error) {
 				const recoveryErrors = [];
 				if (rollbackRuntimeState) try {
@@ -10696,7 +10768,7 @@ var PanelAppPackageStateManager = class {
 		try {
 			return await this.params.sourceService.resolveSource(this.params.getPanelsPath(), id);
 		} catch (error) {
-			if (!isPanelAppError(error) || error.code !== "PANEL_APP_NOT_FOUND") throw error;
+			if (!isPanelAppError(error) || error.code !== "PANEL_APP_NOT_FOUND" && error.code !== "PANEL_APP_INVALID_ID") throw error;
 		}
 		const match = (await this.listSources()).find(({ source, packageSource }) => packageSource && (encodePanelAppId(source.sourceName) === id || packageSource.id === id));
 		if (!match) throw new PanelAppError("PANEL_APP_NOT_FOUND", "panel app not found");
@@ -10707,16 +10779,34 @@ var PanelAppPackageStateManager = class {
 	};
 	readContentSourceByIdOrAppId = async (id) => {
 		const panelsPath = this.params.getPanelsPath();
-		for (const { source, packageSource } of await this.listSources()) {
-			const manifest = source.manifest ?? parsePanelAppManifest(await readFile(source.entryPath, "utf8"));
-			if (encodePanelAppId(source.sourceName) !== id && resolvePanelAppAppId(source, manifest) !== id && packageSource?.id !== id) continue;
-			return await readPanelAppContentSourceByIdOrPath({
-				createAssetBaseHref: this.params.createAssetBaseHref,
-				id,
-				panelsPath,
-				sourcePath: source.sourcePath,
-				sourceService: this.params.sourceService
-			});
+		const { source } = await this.resolveSourceByIdOrAppId(id);
+		return await readPanelAppContentSourceByIdOrPath({
+			createAssetBaseHref: this.params.createAssetBaseHref,
+			id,
+			panelsPath,
+			sourcePath: source.sourcePath,
+			sourceService: this.params.sourceService
+		});
+	};
+	resolveSourceByIdOrAppId = async (id) => {
+		const panelsPath = this.params.getPanelsPath();
+		try {
+			return await this.toResolvedTarget(await this.params.sourceService.resolveSource(panelsPath, id));
+		} catch (error) {
+			if (!isPanelAppError(error) || error.code !== "PANEL_APP_NOT_FOUND" && error.code !== "PANEL_APP_INVALID_ID") throw error;
+		}
+		const packageSources = (await this.listPackageComponentSources()).filter((component) => component.kind === "panel");
+		const exactPackageSource = packageSources.find((component) => component.id === id);
+		if (exactPackageSource) return await this.toResolvedTarget(await this.params.sourceService.resolveSourcePath(exactPackageSource.sourcePath), exactPackageSource);
+		const workspaceSources = await this.params.sourceService.listSources(panelsPath);
+		for (const source of workspaceSources) {
+			const target = await this.toResolvedTarget(source);
+			if (resolvePanelAppAppId(source, target.manifest) === id) return target;
+		}
+		for (const packageSource of packageSources) {
+			const source = await this.params.sourceService.resolveSourcePath(packageSource.sourcePath);
+			const target = await this.toResolvedTarget(source, packageSource);
+			if (encodePanelAppId(source.sourceName) === id || resolvePanelAppAppId(source, target.manifest) === id) return target;
 		}
 		throw new PanelAppError("PANEL_APP_NOT_FOUND", "panel app not found");
 	};
@@ -10795,6 +10885,11 @@ var PanelAppPackageStateManager = class {
 		return errors;
 	};
 	listPackageComponentSources = async () => await this.params.listPackageComponentSources?.() ?? [];
+	toResolvedTarget = async (source, packageSource) => ({
+		source,
+		packageSource,
+		manifest: source.manifest ?? parsePanelAppManifest(await readFile(source.entryPath, "utf8"))
+	});
 };
 //#endregion
 //#region src/utils/panel-app-time.utils.ts
@@ -11964,6 +12059,12 @@ var PanelAppManager = class {
 			unavailablePackages: await this.params.listPackageComponentDiagnostics?.() ?? []
 		};
 	};
+	getPanelApp = async (id) => {
+		const panelsPath = this.getPanelsPath(this.getWorkspacePath());
+		const resolved = await this.packageStateManager.resolveSourceByIdOrAppId(id);
+		const appState = await this.createStateStore(panelsPath).load();
+		return await this.entryPresenter.build(resolved.source, appState.apps[encodePanelAppId(resolved.source.sourceName)] ?? {}, resolved.packageSource, appState.mainSidebarAppIds);
+	};
 	getPanelAppContent = async (id, sourcePath) => {
 		try {
 			const resolved = sourcePath ? await readPanelAppContentSourceByIdOrPath({
@@ -12101,19 +12202,19 @@ var PanelAppManager = class {
 		return await this.agentBridgeService.grantAgentCapability(bridgeSession, capability);
 	};
 	updatePanelAppPreferences = async (id, preferences) => {
-		const fileName = await this.resolvePanelAppFileName(id);
 		const panelsPath = this.getPanelsPath(this.getWorkspacePath());
-		const source = await this.packageStateManager.resolveSource(encodePanelAppId(fileName));
-		const packageSource = await this.packageStateManager.findPackageSourceBySourceName(fileName);
-		const appId = resolvePanelAppAppId(source, source.manifest ?? parsePanelAppManifest(await readFile(source.entryPath, "utf8")));
+		const resolved = await this.packageStateManager.resolveSourceByIdOrAppId(id);
+		const fileName = resolved.source.sourceName;
+		const appId = resolvePanelAppAppId(resolved.source, resolved.manifest);
 		const result = await this.createStateStore(panelsPath).updatePreferences(encodePanelAppId(fileName), appId, preferences);
-		return await this.entryPresenter.build(source, result.entry, packageSource, result.mainSidebarAppIds);
+		return await this.entryPresenter.build(resolved.source, result.entry, resolved.packageSource, result.mainSidebarAppIds);
 	};
 	recordPanelAppOpened = async (id) => {
-		const fileName = await this.resolvePanelAppFileName(id);
 		const panelsPath = this.getPanelsPath(this.getWorkspacePath());
+		const resolved = await this.packageStateManager.resolveSourceByIdOrAppId(id);
+		const fileName = resolved.source.sourceName;
 		const result = await this.createStateStore(panelsPath).recordOpened(encodePanelAppId(fileName));
-		return await this.entryPresenter.build(await this.packageStateManager.resolveSource(encodePanelAppId(fileName)), result.entry, await this.packageStateManager.findPackageSourceBySourceName(fileName), result.mainSidebarAppIds);
+		return await this.entryPresenter.build(resolved.source, result.entry, resolved.packageSource, result.mainSidebarAppIds);
 	};
 	deletePanelApp = async (id) => {
 		const panelsPath = this.getPanelsPath(this.getWorkspacePath());
@@ -12146,9 +12247,6 @@ var PanelAppManager = class {
 		return `${PANEL_APP_TOKENIZED_ASSET_BASE_PATH}/${encodeURIComponent(token)}/`;
 	};
 	createStateStore = (panelsPath) => new PanelAppStateStore(panelsPath);
-	resolvePanelAppFileName = async (id) => {
-		return (await this.packageStateManager.resolveSource(id)).sourceName;
-	};
 	assertCanActivatePackageComponents = async (components) => await this.packageStateManager.assertCanActivate(components);
 	deactivatePackageComponents = (components) => this.packageStateManager.deactivate(components);
 	preparePackageComponentDeactivation = (components) => {
@@ -20329,7 +20427,7 @@ var ObservationManager = class {
 };
 //#endregion
 //#region src/features/projects/stores/project.store.ts
-const PROJECT_STORE_VERSION = 2;
+const PROJECT_STORE_VERSION = 3;
 function createProjectId() {
 	return randomBytes(9).toString("base64url");
 }
@@ -20368,17 +20466,18 @@ var ProjectStore = class {
 			throw error;
 		}
 		if (storeFile.version === PROJECT_STORE_VERSION) return false;
-		await this.save(storeFile.projects.map((project) => ({
+		await this.save(storeFile.version === 1 ? storeFile.projects.map((project) => ({
 			id: createProjectId(),
 			...project
-		})));
+		})) : storeFile.projects);
 		return true;
 	};
-	save = async (projects) => {
+	save = async (projects, removedProjects = []) => {
 		const tempPath = `${this.storePath}.${randomUUID()}.tmp`;
 		const storeFile = {
 			version: PROJECT_STORE_VERSION,
-			projects
+			projects,
+			removedProjects
 		};
 		await mkdir(dirname(this.storePath), { recursive: true });
 		try {
@@ -20389,19 +20488,57 @@ var ProjectStore = class {
 			throw error;
 		}
 	};
+	remove = async (projectId) => {
+		const storeFile = await this.readStoreFile();
+		const project = storeFile.projects.find((entry) => entry.id === projectId);
+		if (!project) return null;
+		await this.save(storeFile.projects.filter((entry) => entry.id !== projectId), [...storeFile.removedProjects.filter((entry) => entry.id !== projectId), project]);
+		return structuredClone(project);
+	};
+	restoreByRootPath = async (rootPath, updatedAt) => {
+		const storeFile = await this.readStoreFile();
+		const project = storeFile.removedProjects.find((entry) => entry.rootPath === rootPath);
+		if (!project) return null;
+		const restored = {
+			...project,
+			updatedAt
+		};
+		await this.save([...storeFile.projects, restored], storeFile.removedProjects.filter((entry) => entry.id !== project.id));
+		return structuredClone(restored);
+	};
+	isRemovedRootPath = async (rootPath) => (await this.readStoreFile()).removedProjects.some((entry) => entry.rootPath === rootPath);
+	readStoreFile = async () => {
+		try {
+			return this.parseStoreFile(await readFile(this.storePath, "utf8"));
+		} catch (error) {
+			if (this.isMissingFileError(error)) return {
+				version: PROJECT_STORE_VERSION,
+				projects: [],
+				removedProjects: []
+			};
+			if (error instanceof SyntaxError) throw new ProjectStoreError("project registry contains invalid JSON");
+			throw error;
+		}
+	};
 	parseStoreFile = (source) => {
 		const value = this.parseStoredFile(source);
-		if (value.version !== PROJECT_STORE_VERSION || !value.projects.every(this.isProjectRecord)) throw new ProjectStoreError("project registry has an unsupported structure");
+		if (value.version !== PROJECT_STORE_VERSION || !value.projects.every(this.isProjectRecord) || !value.removedProjects.every(this.isProjectRecord)) throw new ProjectStoreError("project registry has an unsupported structure");
 		return {
 			version: PROJECT_STORE_VERSION,
-			projects: value.projects.map((project) => structuredClone(project))
+			projects: value.projects.map((project) => structuredClone(project)),
+			removedProjects: value.removedProjects.map((project) => structuredClone(project))
 		};
 	};
 	parseStoredFile = (source) => {
 		const value = JSON.parse(source);
 		if (!this.isRecord(value) || !Array.isArray(value.projects)) throw new ProjectStoreError("project registry has an unsupported structure");
-		if (value.version === PROJECT_STORE_VERSION && value.projects.every(this.isProjectRecord)) return {
+		if (value.version === PROJECT_STORE_VERSION && Array.isArray(value.removedProjects) && value.projects.every(this.isProjectRecord) && value.removedProjects.every(this.isProjectRecord)) return {
 			version: PROJECT_STORE_VERSION,
+			projects: value.projects.map((project) => structuredClone(project)),
+			removedProjects: value.removedProjects.map((project) => structuredClone(project))
+		};
+		if (value.version === 2 && value.projects.every(this.isProjectRecord)) return {
+			version: 2,
 			projects: value.projects.map((project) => structuredClone(project))
 		};
 		if (value.version === 1 && value.projects.every(this.isLegacyProjectRecord)) return {
@@ -20487,7 +20624,15 @@ var ProjectManager = class {
 			name,
 			rootPath,
 			template
-		});
+		}, { restoreRemoved: true });
+	};
+	addExistingProject = async (rootPath, name) => {
+		const canonicalPath = await this.resolveExistingProjectRoot(rootPath);
+		if (!canonicalPath) return null;
+		return await this.upsertProject({
+			name: name === void 0 ? basename(canonicalPath) : this.normalizeName(name),
+			rootPath: canonicalPath
+		}, { restoreRemoved: true });
 	};
 	registerExistingProject = async (rootPath, name) => {
 		const canonicalPath = await this.resolveExistingProjectRoot(rootPath);
@@ -20495,7 +20640,13 @@ var ProjectManager = class {
 		return await this.upsertProject({
 			name: name === void 0 ? basename(canonicalPath) : this.normalizeName(name),
 			rootPath: canonicalPath
-		});
+		}, { restoreRemoved: true });
+	};
+	removeProject = async (projectId, confirmProjectId) => {
+		if (confirmProjectId !== projectId) throw new ProjectError("PROJECT_REMOVE_CONFIRMATION_MISMATCH", "project removal confirmation must exactly match the project id");
+		const removed = await this.store.remove(projectId);
+		if (!removed) throw new ProjectError("PROJECT_NOT_FOUND", "project was not found");
+		return removed;
 	};
 	normalizeSessionProjectRoot = async (value) => {
 		return (await this.normalizeSessionProjectContext(value))?.rootPath ?? null;
@@ -20529,18 +20680,30 @@ var ProjectManager = class {
 		for (const projectRoot of projectRoots) {
 			if (projectRoot == null || typeof projectRoot === "string" && !projectRoot.trim()) continue;
 			try {
-				await this.registerExistingProject(projectRoot);
+				const canonicalPath = await this.resolveExistingProjectRoot(projectRoot);
+				if (!canonicalPath || await this.store.isRemovedRootPath(canonicalPath)) continue;
+				await this.upsertProject({
+					name: basename(canonicalPath),
+					rootPath: canonicalPath
+				});
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
 				console.warn(`[project-manager] skipped historical project root: ${message}`);
 			}
 		}
 	};
-	upsertProject = async (input) => {
+	upsertProject = async (input, options = {}) => {
 		const projects = await this.store.list();
 		const existing = projects.find((project) => project.rootPath === input.rootPath);
 		if (existing) return existing;
 		const now = (/* @__PURE__ */ new Date()).toISOString();
+		if (options.restoreRemoved) {
+			const restored = await this.store.restoreByRootPath(input.rootPath, now);
+			if (restored) {
+				await this.options.onProjectRegistered?.(structuredClone(restored));
+				return restored;
+			}
+		}
 		const project = {
 			id: createProjectId(),
 			name: input.name,
@@ -20854,6 +21017,95 @@ function toArtifactLink(row) {
 	};
 }
 //#endregion
+//#region src/features/projects/stores/project-work-query.store.ts
+var ProjectWorkQueryStore = class {
+	constructor(db, toItem) {
+		this.db = db;
+		this.toItem = toItem;
+	}
+	listItems = (params) => {
+		const { cursor, includeDeleted, limit, projectId, stateId } = params;
+		const conditions = ["items.project_id = ?"];
+		const values = [projectId];
+		if (!includeDeleted) conditions.push("items.deleted_at IS NULL");
+		if (stateId) {
+			conditions.push("items.state_id = ?");
+			values.push(stateId);
+		}
+		const total = Number(this.db().prepare(`SELECT COUNT(*) AS count FROM project_work_items AS items
+             WHERE ${conditions.join(" AND ")}`).get(...values).count);
+		if (cursor) {
+			conditions.push("(items.updated_at < ? OR (items.updated_at = ? AND items.id < ?))");
+			values.push(cursor.updatedAt, cursor.updatedAt, cursor.id);
+		}
+		const rows = this.db().prepare(`SELECT items.*,
+          (SELECT COUNT(*) FROM project_work_artifact_links AS links
+           WHERE links.project_id = items.project_id AND links.work_item_id = items.id) AS artifact_count
+         FROM project_work_items AS items
+         WHERE ${conditions.join(" AND ")}
+         ORDER BY items.updated_at DESC, items.id DESC
+         LIMIT ?`).all(...values, limit + 1);
+		return {
+			items: rows.slice(0, limit).map((row) => ({
+				...this.toItem(row),
+				artifactCount: Number(row.artifact_count)
+			})),
+			hasMore: rows.length > limit,
+			total
+		};
+	};
+	summarizeItems = (projectId) => {
+		const row = this.db().prepare(`SELECT
+          COUNT(*) AS total,
+          SUM(CASE WHEN states.category NOT IN ('completed', 'canceled') THEN 1 ELSE 0 END) AS active,
+          SUM(CASE WHEN states.category = 'completed' THEN 1 ELSE 0 END) AS completed,
+          SUM(CASE WHEN items.attention != 'none' THEN 1 ELSE 0 END) AS attention,
+          MAX(items.updated_at) AS updated_at
+         FROM project_work_items AS items
+         JOIN project_work_states AS states
+           ON states.project_id = items.project_id AND states.id = items.state_id
+         WHERE items.project_id = ? AND items.deleted_at IS NULL`).get(projectId);
+		return {
+			total: Number(row.total),
+			active: Number(row.active ?? 0),
+			completed: Number(row.completed ?? 0),
+			attention: Number(row.attention ?? 0),
+			updatedAt: row.updated_at
+		};
+	};
+	listRecentArtifacts = (params) => {
+		const { cursor, limit, projectId } = params;
+		const total = Number(this.db().prepare("SELECT COUNT(DISTINCT path) AS count FROM project_work_artifact_links WHERE project_id = ?").get(projectId).count);
+		const cursorCondition = cursor ? "AND (created_at < ? OR (created_at = ? AND id < ?))" : "";
+		const rows = this.db().prepare(`WITH ranked AS (
+          SELECT links.id, links.path, links.label, links.work_item_id,
+            items.title AS work_item_title, links.created_at,
+            ROW_NUMBER() OVER (
+              PARTITION BY links.path
+              ORDER BY links.created_at DESC, links.id DESC
+            ) AS path_rank
+          FROM project_work_artifact_links AS links
+          JOIN project_work_items AS items
+            ON items.project_id = links.project_id AND items.id = links.work_item_id
+          WHERE links.project_id = ?
+        )
+        SELECT id, path, label, work_item_id, work_item_title, created_at
+        FROM ranked
+        WHERE path_rank = 1 ${cursorCondition}
+        ORDER BY created_at DESC, id DESC
+        LIMIT ?`).all(projectId, ...cursor ? [
+			cursor.createdAt,
+			cursor.createdAt,
+			cursor.id
+		] : [], limit + 1);
+		return {
+			artifacts: rows.slice(0, limit),
+			hasMore: rows.length > limit,
+			total
+		};
+	};
+};
+//#endregion
 //#region src/features/projects/stores/project-work-state.store.ts
 const DEFAULT_PROJECT_WORK_STATES = [
 	{
@@ -21007,6 +21259,7 @@ var ProjectWorkStore = class {
 	database = null;
 	readyPromise = null;
 	activities = new ProjectWorkActivityStore(() => this.db());
+	queries = new ProjectWorkQueryStore(() => this.db(), toItem);
 	states = new ProjectWorkStateStore(() => this.db(), this.activities.insertActivity);
 	constructor(databasePath) {
 		this.databasePath = databasePath;
@@ -21041,12 +21294,6 @@ var ProjectWorkStore = class {
 		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);
@@ -21193,8 +21440,12 @@ var ProjectWorkStore = class {
       );
       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_items_state_list_idx
+      ON project_work_items(project_id, state_id, deleted_at, updated_at, id);
       CREATE INDEX IF NOT EXISTS project_work_activity_timeline_idx
       ON project_work_activities(project_id, work_item_id, created_at);
+      CREATE INDEX IF NOT EXISTS project_work_artifacts_recent_idx
+      ON project_work_artifact_links(project_id, created_at, id);
     `);
 	};
 	db = () => {
@@ -21242,6 +21493,112 @@ function isProjectWorkError(error) {
 	return error instanceof ProjectWorkError;
 }
 //#endregion
+//#region src/features/projects/services/project-work-query.service.ts
+var ProjectWorkQueryService = class {
+	constructor(store, projectManager) {
+		this.store = store;
+		this.projectManager = projectManager;
+	}
+	list = async (projectId, input = {}) => {
+		await this.ensureProject(projectId);
+		const limit = this.requirePageLimit(input.limit);
+		const cursor = input.cursor ? this.decodeCursor(input.cursor, "work item", "updatedAt") : void 0;
+		const states = await this.store.listStates(projectId);
+		if (input.stateId && !states.some((state) => state.id === input.stateId)) throw new ProjectWorkError("PROJECT_WORK_STATE_NOT_FOUND", "work item state was not found");
+		const page = this.store.queries.listItems({
+			projectId,
+			includeDeleted: input.includeDeleted ?? false,
+			limit,
+			...input.stateId ? { stateId: input.stateId } : {},
+			...cursor ? { cursor } : {}
+		});
+		const stateById = new Map(states.map((state) => [state.id, state]));
+		const items = page.items.map((item) => ({
+			...item,
+			state: this.requireMappedState(stateById, item.stateId)
+		}));
+		const last = items.at(-1);
+		return {
+			items,
+			total: page.total,
+			nextCursor: page.hasMore && last ? this.encodeCursor({
+				updatedAt: last.updatedAt,
+				id: last.id
+			}) : null
+		};
+	};
+	summary = async (projectId) => {
+		await this.ensureProject(projectId);
+		return this.store.queries.summarizeItems(projectId);
+	};
+	listRecentArtifacts = async (projectId, input = {}) => {
+		const project = await this.requireProject(projectId);
+		await this.store.ensureProject(projectId);
+		const limit = this.requirePageLimit(input.limit);
+		const cursor = input.cursor ? this.decodeCursor(input.cursor, "project artifact", "createdAt") : void 0;
+		const page = this.store.queries.listRecentArtifacts({
+			projectId,
+			limit,
+			...cursor ? { cursor } : {}
+		});
+		const artifacts = await Promise.all(page.artifacts.map(async (artifact) => ({
+			id: artifact.id,
+			path: artifact.path,
+			label: artifact.label,
+			workItemId: artifact.work_item_id,
+			workItemTitle: artifact.work_item_title,
+			createdAt: artifact.created_at,
+			exists: await this.isArtifactAvailable(project.rootPath, artifact.path)
+		})));
+		const last = artifacts.at(-1);
+		return {
+			artifacts,
+			total: page.total,
+			nextCursor: page.hasMore && last ? this.encodeCursor({
+				createdAt: last.createdAt,
+				id: last.id
+			}) : null
+		};
+	};
+	ensureProject = async (projectId) => {
+		await this.requireProject(projectId);
+		await this.store.ensureProject(projectId);
+	};
+	requireProject = async (projectId) => {
+		const normalized = projectId.trim();
+		const project = normalized ? await this.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;
+	};
+	requirePageLimit = (value) => {
+		const limit = value ?? 20;
+		if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw new ProjectWorkError("PROJECT_WORK_VALIDATION_FAILED", "page limit must be an integer between 1 and 100");
+		return limit;
+	};
+	encodeCursor = (value) => Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
+	decodeCursor = (value, label, timestampKey) => {
+		try {
+			const decoded = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+			if (!decoded || typeof decoded !== "object" || typeof decoded.id !== "string" || typeof decoded[timestampKey] !== "string" || Object.keys(decoded).some((key) => key !== "id" && key !== timestampKey) || Object.values(decoded).some((entry) => typeof entry !== "string" || !entry)) throw new Error("invalid cursor shape");
+			return decoded;
+		} catch {
+			throw new ProjectWorkError("PROJECT_WORK_VALIDATION_FAILED", `${label} cursor is invalid`);
+		}
+	};
+	isArtifactAvailable = async (projectRoot, projectRelativePath) => {
+		try {
+			return (await stat(resolve(projectRoot, projectRelativePath))).isFile();
+		} catch {
+			return false;
+		}
+	};
+};
+//#endregion
 //#region src/features/projects/types/project-work.types.ts
 const PROJECT_WORK_STATE_CATEGORIES = [
 	"backlog",
@@ -21259,9 +21616,11 @@ const PROJECT_WORK_ATTENTION_VALUES = [
 //#region src/features/projects/managers/project-work.manager.ts
 var ProjectWorkManager = class {
 	store;
+	queries;
 	constructor(options) {
 		this.options = options;
 		this.store = new ProjectWorkStore(options.databasePath);
+		this.queries = new ProjectWorkQueryService(this.store, options.projectManager);
 	}
 	initialize = async () => {
 		await this.store.initialize();
@@ -21272,31 +21631,9 @@ var ProjectWorkManager = class {
 		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
-		};
-	};
+	list = async (projectId, input = {}) => await this.queries.list(projectId, input);
+	summary = async (projectId) => await this.queries.summary(projectId);
+	listRecentArtifacts = async (projectId, input = {}) => await this.queries.listRecentArtifacts(projectId, input);
 	get = async (projectId, workItemId) => {
 		await this.ensureProject(projectId);
 		const item = await this.store.getItem(projectId, workItemId);
@@ -21465,11 +21802,6 @@ var ProjectWorkManager = class {
 		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`);
@@ -26702,13 +27034,29 @@ function agentActor(context) {
 }
 var ProjectWorkListTool = class {
 	name = "project_work_list";
-	description = "List persistent work items and custom states for the current project.";
+	description = "List one bounded page of persistent work items for the current project.";
 	parameters = {
 		type: "object",
-		properties: { include_deleted: {
-			type: "boolean",
-			description: "Include deleted work items."
-		} },
+		properties: {
+			include_deleted: {
+				type: "boolean",
+				description: "Include deleted work items."
+			},
+			state_id: {
+				type: "string",
+				description: "Only return work items in this custom state."
+			},
+			cursor: {
+				type: "string",
+				description: "Opaque next_cursor from an earlier list response."
+			},
+			limit: {
+				type: "integer",
+				minimum: 1,
+				maximum: 100,
+				description: "Page size. Defaults to 20."
+			}
+		},
 		additionalProperties: false
 	};
 	constructor(work, context) {
@@ -26717,7 +27065,12 @@ var ProjectWorkListTool = class {
 	}
 	execute = async (args) => {
 		const params = normalizeToolParams(args);
-		return JSON.stringify(await this.work.list(this.context.projectId, optionalBoolean(params.include_deleted) ?? false), null, 2);
+		return JSON.stringify(await this.work.list(this.context.projectId, {
+			includeDeleted: optionalBoolean(params.include_deleted) ?? false,
+			...optionalString$1(params.state_id) ? { stateId: optionalString$1(params.state_id) } : {},
+			...optionalString$1(params.cursor) ? { cursor: optionalString$1(params.cursor) } : {},
+			...optionalNumber(params.limit) ? { limit: optionalNumber(params.limit) } : {}
+		}), null, 2);
 	};
 };
 var ProjectWorkGetTool = class {