@xopcai/xopc 0.0.173 → 0.0.175

package/dist/src/gateway/hono/routes/work-discovery.js

@@ -1,10 +1,6 @@
 import { getAgentDefaultModelRef, init_schema } from "../../../config/schema.js";
 import { init_providers, resolveModel } from "../../../providers/index.js";
 import { isLocalModelBaseUrl } from "../../../providers/model-call.js";
-import { listFocusCalendarSignals } from "../../../proactive/calendar-signals.js";
-import { FocusService } from "../../../proactive/focus-service.js";
-import { claimProactiveInsightApproval, getProactiveInsight, setProactiveInsightStatus } from "../../../proactive/insight-repository.js";
-import "../../../proactive/index.js";
 import { previewWorkDiscoveryRoot } from "../../../work-discovery/probe.js";
 import { WorkDiscoveryService } from "../../../work-discovery/service.js";
 //#region src/gateway/hono/routes/work-discovery.ts
@@ -30,7 +26,6 @@ function stringField(body, field) {
 }
 function registerWorkDiscoveryRoutes(authenticated, deps) {
 	const service = workDiscoveryService(deps);
-	const focuses = new FocusService(deps.service.automationServiceInstance);
 	const limited = deps.strictRateLimitMiddleware;
 	authenticated.get("/api/onboarding/work-discovery", (c) => c.json({
 		enabled: service.isEnabled(),
@@ -304,240 +299,6 @@ function registerWorkDiscoveryRoutes(authenticated, deps) {
 			error: "Investigation not found"
 		}, 404);
 	});
-	authenticated.get("/api/work-understanding/threads", (c) => {
-		const projectId = c.req.query("projectId")?.trim();
-		const limit = Number(c.req.query("limit"));
-		return c.json({
-			ok: true,
-			threads: service.listWorkThreads({
-				...projectId ? { projectId } : {},
-				...Number.isFinite(limit) ? { limit } : {}
-			})
-		});
-	});
-	authenticated.get("/api/work-understanding/metrics", (c) => c.json({
-		ok: true,
-		metrics: service.getUnderstandingMetrics()
-	}));
-	authenticated.get("/api/work-understanding/sources/:sourceId/lineage", (c) => {
-		const lineage = service.getSourceLineage(c.req.param("sourceId"));
-		return lineage ? c.json({
-			ok: true,
-			lineage
-		}) : c.json({
-			ok: false,
-			error: "Source not found"
-		}, 404);
-	});
-	authenticated.delete("/api/work-understanding/sources/:sourceId/derived-data", limited, (c) => {
-		const deleted = service.deleteSourceDerivedData(c.req.param("sourceId"));
-		return deleted ? c.json({
-			ok: true,
-			deleted
-		}) : c.json({
-			ok: false,
-			error: "Source not found"
-		}, 404);
-	});
-	authenticated.get("/api/work-understanding/threads/:threadId", (c) => {
-		const thread = service.getWorkThread(c.req.param("threadId"));
-		return thread ? c.json({
-			ok: true,
-			thread
-		}) : c.json({
-			ok: false,
-			error: "Work thread not found"
-		}, 404);
-	});
-	authenticated.patch("/api/work-understanding/threads/:threadId", limited, async (c) => {
-		const body = await c.req.json().catch(() => null);
-		const decision = stringField(body, "decision");
-		if (![
-			"confirmed",
-			"corrected",
-			"rejected",
-			"paused",
-			"completed"
-		].includes(decision)) return c.json({
-			ok: false,
-			error: "Invalid work thread decision"
-		}, 400);
-		const thread = service.updateWorkThread({
-			id: c.req.param("threadId"),
-			decision,
-			...stringField(body, "correctedTitle") ? { correctedTitle: stringField(body, "correctedTitle") } : {},
-			...stringField(body, "correctedSummary") ? { correctedSummary: stringField(body, "correctedSummary") } : {}
-		});
-		return thread ? c.json({
-			ok: true,
-			thread
-		}) : c.json({
-			ok: false,
-			error: "Work thread not found"
-		}, 404);
-	});
-	authenticated.get("/api/focuses", (c) => {
-		return c.json({
-			ok: true,
-			focuses: focuses.list({ includeUnreviewed: c.req.query("includeUnreviewed") === "true" })
-		});
-	});
-	authenticated.post("/api/focuses/:focusId/confirm", limited, (c) => {
-		const focus = focuses.confirm(c.req.param("focusId"));
-		return focus ? c.json({
-			ok: true,
-			focus
-		}) : c.json({
-			ok: false,
-			error: "Focus not found"
-		}, 404);
-	});
-	authenticated.post("/api/focuses/:focusId/watches/trial", limited, async (c) => {
-		const requestedKind = stringField(await c.req.json().catch(() => null), "kind");
-		const kind = [
-			"progress",
-			"staleness",
-			"deadline",
-			"intelligence"
-		].includes(requestedKind) ? requestedKind : void 0;
-		try {
-			const result = await focuses.activateTrial({
-				threadId: c.req.param("focusId"),
-				...kind ? { kind } : {}
-			});
-			return c.json({
-				ok: true,
-				...result
-			}, 201);
-		} catch (error) {
-			return c.json({
-				ok: false,
-				error: error instanceof Error ? error.message : String(error)
-			}, 400);
-		}
-	});
-	authenticated.post("/api/focuses/:focusId/watches/:watchId/pause", limited, async (c) => {
-		const watch = focuses.list({ includeUnreviewed: true }).find((item) => item.id === c.req.param("focusId"))?.watches.find((item) => item.id === c.req.param("watchId"));
-		if (!watch) return c.json({
-			ok: false,
-			error: "Watch not found"
-		}, 404);
-		const paused = await focuses.pauseWatch(watch.id);
-		return c.json({
-			ok: true,
-			watch: paused
-		});
-	});
-	authenticated.patch("/api/proactive/insights/:insightId", limited, async (c) => {
-		const requested = stringField(await c.req.json().catch(() => null), "status");
-		const status = requested === "read" || requested === "dismissed" ? requested : void 0;
-		if (!status) return c.json({
-			ok: false,
-			error: "Status must be read or dismissed"
-		}, 400);
-		const insight = setProactiveInsightStatus(c.req.param("insightId"), status, Date.now(), "unread");
-		if (!insight) return c.json({
-			ok: false,
-			error: "Insight was already handled or not found"
-		}, 409);
-		if (status === "dismissed") await focuses.recordInsightFeedback(insight.watchId, false);
-		return c.json({
-			ok: true,
-			insight
-		});
-	});
-	authenticated.post("/api/proactive/insights/:insightId/approve", limited, async (c) => {
-		const insight = getProactiveInsight(c.req.param("insightId"));
-		if (!insight) return c.json({
-			ok: false,
-			error: "Insight not found"
-		}, 404);
-		if (insight.status !== "unread") return c.json({
-			ok: false,
-			error: `Insight is ${insight.status}`
-		}, 409);
-		const focus = focuses.list({ includeUnreviewed: true }).find((item) => item.watches.some((watch) => watch.id === insight.watchId));
-		if (!focus) return c.json({
-			ok: false,
-			error: "Focus not found"
-		}, 404);
-		if (!claimProactiveInsightApproval(insight.id)) return c.json({
-			ok: false,
-			error: "Insight was already handled"
-		}, 409);
-		let automationId;
-		try {
-			const automation = await deps.service.automationServiceInstance.create({
-				name: `Investigate: ${insight.title}`.slice(0, 200),
-				description: `User-approved read-only proposal from proactive insight ${insight.id}.`,
-				...focus.projectIds[0] ? { projectId: focus.projectIds[0] } : {},
-				trigger: { kind: "manual" },
-				action: {
-					kind: "agent",
-					instruction: [
-						"The user approved this evidence-backed proposal for read-only investigation and preparation.",
-						`Focus: ${focus.title}`,
-						`Observed change: ${insight.summary}`,
-						`Why it matters: ${insight.whyItMatters}`,
-						`Approved next step: ${insight.nextAction}`,
-						`Evidence: ${JSON.stringify(insight.evidence)}`,
-						"Investigate or prepare the requested material. Return a concise result with evidence. Do not modify files or external systems."
-					].join("\n"),
-					timeoutSeconds: 300
-				},
-				safety: { mode: "suggest_only" },
-				afterRun: { kind: "none" },
-				reliability: {
-					timeoutSeconds: 300,
-					disableAfterConsecutiveFailures: 1
-				}
-			});
-			automationId = automation.id;
-			const run = await deps.service.automationServiceInstance.runNow(automation.id);
-			await focuses.recordInsightFeedback(insight.watchId, true);
-			return c.json({
-				ok: true,
-				automationId: automation.id,
-				runId: run.id
-			}, 202);
-		} catch (error) {
-			if (automationId) await deps.service.automationServiceInstance.remove(automationId);
-			setProactiveInsightStatus(insight.id, "unread", Date.now(), "approved");
-			return c.json({
-				ok: false,
-				error: error instanceof Error ? error.message : String(error)
-			}, 500);
-		}
-	});
-	authenticated.post("/api/focuses/:focusId/calendar/:signalId/prepare", limited, async (c) => {
-		const focus = focuses.list().find((item) => item.id === c.req.param("focusId"));
-		if (!focus) return c.json({
-			ok: false,
-			error: "Focus not found"
-		}, 404);
-		const signal = listFocusCalendarSignals([focus]).find((item) => item.id === c.req.param("signalId"));
-		if (!signal) return c.json({
-			ok: false,
-			error: "Calendar event not found"
-		}, 404);
-		const eventContext = `${signal.title} at ${new Date(signal.startsAt).toISOString()}`;
-		try {
-			const result = await focuses.activateTrial({
-				threadId: focus.id,
-				kind: "deadline",
-				eventContext
-			});
-			return c.json({
-				ok: true,
-				...result
-			});
-		} catch (error) {
-			return c.json({
-				ok: false,
-				error: error instanceof Error ? error.message : String(error)
-			}, 500);
-		}
-	});
 	authenticated.post("/api/work-discovery/runs/:runId/cancel", (c) => {
 		const run = service.cancelRun(c.req.param("runId"));
 		return run ? c.json({

package/dist/src/gateway/service.d.ts

@@ -68,7 +68,7 @@ export declare class GatewayService {
     private connectedKnowledgeCoordinator;
     private stopAutomationProductEventBridge;
     private stopSessionTranscriptAutomationEvents;
-    private stopFocusTrialExpiryReconciler;
+    private stopFocusReconciler;
     /**
      * Webchat agent invocation surface (`runAgent`, `abortAgentRun`, `steer*`,
      * `submitClarifyResponse`, clarify-bridge dispatch). Owns the

package/dist/src/gateway/service.js

@@ -46,14 +46,12 @@ import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js"
 import "../knowledge/index.js";
 import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
 import { startConnectorSupervisor } from "../connectors/supervisor.js";
-import { LocalAppService } from "../local-apps/service.js";
-import "../local-apps/index.js";
+import { FocusService } from "../focuses/service.js";
+import { processFocusMonitorRun } from "../focuses/run-processor.js";
+import { startFocusReconciler } from "../focuses/reconciler.js";
+import "../focuses/index.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { reconcileDreamingAutomations } from "./dreaming-automation-reconciler.js";
-import { FocusService } from "../proactive/focus-service.js";
-import { processFocusAutomationRun } from "../proactive/run-processor.js";
-import { startTrialExpiryReconciler } from "../proactive/trial-expiry-reconciler.js";
-import "../proactive/index.js";
 import { NotesStore } from "../notes/store.js";
 import { buildNoteAgentContext } from "../notes/agent-context.js";
 import { NotesService } from "../notes/service.js";
@@ -79,6 +77,8 @@ import { auditGatewayConfig } from "./security/audit.js";
 import { ModelCatalogSyncService } from "../providers/model-catalog-sync-service.js";
 import { runBootstrapMigrationsSync } from "../migrations/runner.js";
 import { MobileNotificationService } from "../mobile/notification-service.js";
+import { LocalAppService } from "../local-apps/service.js";
+import "../local-apps/index.js";
 import { createRuntimeBrowserRecipeService } from "../browser/recipes/runtime-service.js";
 import "../browser/recipes/index.js";
 import { scheduleGatewayUpdateCheck } from "../infra/update-startup.js";
@@ -163,7 +163,7 @@ var GatewayService = class {
 	connectedKnowledgeCoordinator = null;
 	stopAutomationProductEventBridge = null;
 	stopSessionTranscriptAutomationEvents = null;
-	stopFocusTrialExpiryReconciler = null;
+	stopFocusReconciler = null;
 	/**
 	* Webchat agent invocation surface (`runAgent`, `abortAgentRun`, `steer*`,
 	* `submitClarifyResponse`, clarify-bridge dispatch). Owns the
@@ -706,7 +706,7 @@ var GatewayService = class {
 		});
 		await trace.measure("automations.initialize", () => this.automationService.initialize());
 		await trace.measure("dreaming.reconcile", () => this.reconcileDreamingAutomations());
-		this.stopFocusTrialExpiryReconciler = startTrialExpiryReconciler(new FocusService(this.automationService));
+		this.stopFocusReconciler = startFocusReconciler(new FocusService(this.automationService));
 		await this.notesService.initialize();
 		this.ensureHeartbeatService().start(heartbeatRunnerConfigFromConfig(this.config));
 		this.connectorSupervisor = startConnectorSupervisor({
@@ -866,8 +866,8 @@ var GatewayService = class {
 		this.lastChannelConnectDeferMode = "auto";
 		this.lastChannelConnectDeferSource = "off";
 		await this.channelManager.stop();
-		await this.stopFocusTrialExpiryReconciler?.();
-		this.stopFocusTrialExpiryReconciler = null;
+		await this.stopFocusReconciler?.();
+		this.stopFocusReconciler = null;
 		await this.automationService.stop();
 		this.stopAutomationProductEventBridge?.();
 		this.stopAutomationProductEventBridge = null;
@@ -1273,12 +1273,16 @@ var GatewayService = class {
 	}
 	handleAutomationRunCompleted(run) {
 		try {
-			const proactive = processFocusAutomationRun(run);
+			const focusResult = processFocusMonitorRun(run);
 			this.emit("automation.run.completed", {
 				run,
-				silent: proactive.handled
+				silent: focusResult.handled
+			});
+			if (focusResult.handled) this.emit("focus.run.updated", {
+				automationId: run.automationId,
+				run
 			});
-			if (proactive.insight) this.emit("proactive.insight.created", { insight: proactive.insight });
+			if (focusResult.insight) this.emit("focus.insight.created", { insight: focusResult.insight });
 		} catch (err) {
 			log.warn({
 				err,

package/dist/src/heartbeat/index.js

@@ -1,6 +1,6 @@
 import { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, shouldSilence, stripHeartbeatToken } from "./tokens.js";
+import { appendCronEventLines } from "./event-prompt.js";
 import { isWithinActiveHours } from "./active-hours.js";
 import { isHeartbeatContentEmpty } from "./content-check.js";
-import { appendCronEventLines } from "./event-prompt.js";
 import { createHeartbeatWake } from "./wake.js";
 export { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, appendCronEventLines, createHeartbeatWake, isHeartbeatContentEmpty, isWithinActiveHours, shouldSilence, stripHeartbeatToken };

package/dist/src/infra/update-restart.js

@@ -2,8 +2,8 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { init_paths, resolveConfigPath } from "../config/paths.js";
 import { init_loader, loadConfig } from "../config/loader.js";
-import { isRestartEnabled } from "../config/commands.flags.js";
 import { resolveGatewayService } from "../daemon/service.js";
+import { isRestartEnabled } from "../config/commands.flags.js";
 import { authorizeGatewaySigusr1Restart, writeGatewayRestartIntentSync } from "./restart.js";
 import { findVerifiedGatewayListenerPidsOnPortSync, signalVerifiedGatewayPidSync } from "./gateway-processes.js";
 import { refreshGatewayServiceAfterUpdate } from "./update-service-refresh.js";

package/dist/src/mcp/channel-bridge.js

@@ -2,9 +2,9 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { init_loader, loadConfig } from "../config/loader.js";
 import { gatewayCredentialAuthorization } from "../gateway/credential.js";
+import { loadUndiciRuntimeDeps } from "../infra/undici-fetch.js";
 import { toConversation } from "./channel-shared.js";
 import { createGatewayHttpClientFromConfig, resolveGatewayHttpBaseUrl } from "./gateway-http-client.js";
-import { loadUndiciRuntimeDeps } from "../infra/undici-fetch.js";
 //#region src/mcp/channel-bridge.ts
 init_loader();
 init_logger();

package/dist/src/projects/index.d.ts

@@ -1,6 +1,7 @@
 export * from './types.js';
 export * from './project-store.js';
 export * from './project-service.js';
+export * from './project-skill-service.js';
 export * from './project-agent.js';
 export * from './project-agent-suggestion.js';
 export * from './project-kind.js';

package/dist/src/projects/index.js

@@ -4,6 +4,7 @@ import { bindGoalToProject, bindGoalsToProject, listProjectGoalIds, unbindGoalFr
 import { bindSessionToProject, bindSessionsToProject, listProjectSessionKeys, moveSessionToProject, unbindSessionFromProject } from "./session-bind.js";
 import { ProjectWorkspaceConflictError, ProjectWorkspaceMissingError, canonicalWorkspacePath, ensureWorkspaceDirectory, inferProjectNameFromWorkspaceRoot, isPathSameOrInsideWorkspace, isSafeAutoCreateWorkspaceRoot, resolveWorkspaceProjectRoot, workspaceDirectoryExists } from "./workspace-project.js";
 import { ProjectService } from "./project-service.js";
+import { ProjectSkillError, ProjectSkillService } from "./project-skill-service.js";
 import { isValidProjectAgentId, normalizeProjectAgentId, resolveProjectAgentId } from "./project-agent.js";
 import { inferProjectKind } from "./project-kind.js";
 import { CODING_PROJECT_AGENT_ID, inferSuggestedProjectDefaultAgentId, suggestProjectDefaultAgentId } from "./project-agent-suggestion.js";
@@ -11,4 +12,4 @@ import { buildProjectLoopOverview } from "./project-loop.js";
 import { bindWorkflowRunToProject } from "./workflow-bind.js";
 import { bindAutomationToProject } from "./automation-bind.js";
 import { bindMemoryRecordToProject } from "./memory-bind.js";
-export { CODING_PROJECT_AGENT_ID, ProjectService, ProjectStore, ProjectWorkspaceConflictError, ProjectWorkspaceMissingError, bindAutomationToProject, bindGoalToProject, bindGoalsToProject, bindMemoryRecordToProject, bindSessionToProject, bindSessionsToProject, bindWorkflowRunToProject, buildProjectLoopOverview, canonicalWorkspacePath, ensureWorkspaceDirectory, getProjectForSession, getProjectWorkspacePathForSession, inferProjectKind, inferProjectNameFromWorkspaceRoot, inferSuggestedProjectDefaultAgentId, isPathSameOrInsideWorkspace, isSafeAutoCreateWorkspaceRoot, isValidProjectAgentId, listProjectGoalIds, listProjectSessionKeys, moveSessionToProject, normalizeProjectAgentId, resolveProjectAgentId, resolveProjectWorkspacePath, resolveWorkspaceProjectRoot, slugifyProjectName, suggestProjectDefaultAgentId, unbindGoalFromProject, unbindSessionFromProject, workspaceDirectoryExists };
+export { CODING_PROJECT_AGENT_ID, ProjectService, ProjectSkillError, ProjectSkillService, ProjectStore, ProjectWorkspaceConflictError, ProjectWorkspaceMissingError, bindAutomationToProject, bindGoalToProject, bindGoalsToProject, bindMemoryRecordToProject, bindSessionToProject, bindSessionsToProject, bindWorkflowRunToProject, buildProjectLoopOverview, canonicalWorkspacePath, ensureWorkspaceDirectory, getProjectForSession, getProjectWorkspacePathForSession, inferProjectKind, inferProjectNameFromWorkspaceRoot, inferSuggestedProjectDefaultAgentId, isPathSameOrInsideWorkspace, isSafeAutoCreateWorkspaceRoot, isValidProjectAgentId, listProjectGoalIds, listProjectSessionKeys, moveSessionToProject, normalizeProjectAgentId, resolveProjectAgentId, resolveProjectWorkspacePath, resolveWorkspaceProjectRoot, slugifyProjectName, suggestProjectDefaultAgentId, unbindGoalFromProject, unbindSessionFromProject, workspaceDirectoryExists };

package/dist/src/projects/project-skill-service.d.ts

@@ -0,0 +1,67 @@
+import type { Config } from '../config/schema.js';
+import type { SkillDiagnostic, SkillMetadata, SkillToolConditions } from '../agent/skills/types.js';
+import type { ProjectService } from './project-service.js';
+export type ProjectSkillErrorCode = 'project_not_found' | 'project_workspace_required' | 'project_workspace_missing' | 'project_workspace_not_writable' | 'skill_not_found' | 'invalid_skill_id';
+export declare class ProjectSkillError extends Error {
+    readonly code: ProjectSkillErrorCode;
+    readonly status: 400 | 403 | 404 | 409;
+    constructor(code: ProjectSkillErrorCode, status: 400 | 403 | 404 | 409, message: string);
+}
+export interface ProjectSkillSummary {
+    id: string;
+    name: string;
+    description: string;
+    category?: string;
+    disableModelInvocation: boolean;
+    metadata: SkillMetadata;
+    toolConditions?: SkillToolConditions;
+    requiredEnvVarNames?: string[];
+}
+export interface ProjectSkillListResult {
+    workspaceRoot: string;
+    skillsRoot: string;
+    items: ProjectSkillSummary[];
+    diagnostics: SkillDiagnostic[];
+}
+interface ProjectSkillServiceOptions {
+    projects: ProjectService;
+    getConfig: () => Config;
+    refreshSkills: () => void | Promise<void>;
+}
+export declare class ProjectSkillService {
+    private readonly options;
+    constructor(options: ProjectSkillServiceOptions);
+    list(projectId: string): ProjectSkillListResult;
+    getContent(projectId: string, skillId: string): ProjectSkillSummary & {
+        bodyMarkdown: string;
+    };
+    installZip(projectId: string, buffer: Buffer, input?: {
+        skillId?: string;
+        overwrite?: boolean;
+    }): Promise<ProjectSkillSummary & {
+        bodyMarkdown: string;
+    }>;
+    installMarketplace(projectId: string, input: {
+        name: string;
+        version?: string;
+        provider?: string;
+        overwrite?: boolean;
+    }): Promise<ProjectSkillSummary & {
+        bodyMarkdown: string;
+    }>;
+    installSource(projectId: string, input: {
+        source: string;
+        skillId?: string;
+        ref?: string;
+        subpath?: string;
+        force?: boolean;
+    }): Promise<ProjectSkillSummary & {
+        bodyMarkdown: string;
+    }>;
+    remove(projectId: string, skillId: string): Promise<void>;
+    private findSkill;
+    private resolveLocation;
+    private isDirectSkill;
+    private toSummary;
+}
+export {};

package/dist/src/projects/project-skill-service.js

@@ -0,0 +1,131 @@
+import { resolveWorkspaceSkillsDir, resolveWorkspaceSkillsLockPath } from "../agent/skills/workspace-skills-dir.js";
+import { loadWorkspaceSkills } from "../agent/skills/index.js";
+import { removeSkillsLockEntry } from "../agent/skills/hub-lock.js";
+import { deleteManagedSkill, installSkillFromZip, isValidSkillId } from "../agent/skills/managed-store.js";
+import { pullSkillFromSource } from "../agent/skills/hub-pull.js";
+import { downloadFromMarketplace } from "../agent/skills/skills-marketplace.js";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { accessSync, constants, existsSync, statSync } from "node:fs";
+//#region src/projects/project-skill-service.ts
+var ProjectSkillError = class extends Error {
+	constructor(code, status, message) {
+		super(message);
+		this.code = code;
+		this.status = status;
+		this.name = "ProjectSkillError";
+	}
+};
+var ProjectSkillService = class {
+	constructor(options) {
+		this.options = options;
+	}
+	list(projectId) {
+		const location = this.resolveLocation(projectId, false);
+		const loaded = loadWorkspaceSkills(location.workspaceRoot);
+		return {
+			...location,
+			items: loaded.skills.filter((skill) => this.isDirectSkill(skill, location.skillsRoot)).map((skill) => this.toSummary(skill)),
+			diagnostics: loaded.diagnostics
+		};
+	}
+	getContent(projectId, skillId) {
+		const { skill } = this.findSkill(projectId, skillId);
+		return {
+			...this.toSummary(skill),
+			bodyMarkdown: skill.content
+		};
+	}
+	async installZip(projectId, buffer, input = {}) {
+		const location = this.resolveLocation(projectId, true);
+		const installed = installSkillFromZip(buffer, {
+			skillId: input.skillId,
+			overwrite: input.overwrite,
+			rootDir: location.skillsRoot
+		});
+		removeSkillsLockEntry(installed.skillId, resolveWorkspaceSkillsLockPath(location.workspaceRoot));
+		await this.options.refreshSkills();
+		return this.getContent(projectId, installed.skillId);
+	}
+	async installMarketplace(projectId, input) {
+		const downloaded = await downloadFromMarketplace(this.options.getConfig(), input.name, input.version, input.provider);
+		return this.installZip(projectId, downloaded.buffer, {
+			skillId: downloaded.skillId,
+			overwrite: input.overwrite
+		});
+	}
+	async installSource(projectId, input) {
+		const location = this.resolveLocation(projectId, true);
+		const installed = await pullSkillFromSource(input.source, {
+			skillId: input.skillId,
+			ref: input.ref,
+			subpath: input.subpath,
+			force: input.force,
+			installRoot: location.skillsRoot,
+			lockPath: resolveWorkspaceSkillsLockPath(location.workspaceRoot)
+		});
+		await this.options.refreshSkills();
+		return this.getContent(projectId, installed.skillId);
+	}
+	async remove(projectId, skillId) {
+		const location = this.resolveLocation(projectId, true);
+		if (!isValidSkillId(skillId)) throw new ProjectSkillError("invalid_skill_id", 400, "Invalid skill id");
+		if (!existsSync(join(location.skillsRoot, skillId, "SKILL.md"))) throw new ProjectSkillError("skill_not_found", 404, "Project skill not found");
+		deleteManagedSkill(skillId, location.skillsRoot);
+		removeSkillsLockEntry(skillId, resolveWorkspaceSkillsLockPath(location.workspaceRoot));
+		await this.options.refreshSkills();
+	}
+	findSkill(projectId, skillId) {
+		if (!isValidSkillId(skillId)) throw new ProjectSkillError("invalid_skill_id", 400, "Invalid skill id");
+		const location = this.resolveLocation(projectId, false);
+		const skill = loadWorkspaceSkills(location.workspaceRoot).skills.find((item) => {
+			return !relative(location.skillsRoot, item.baseDir).includes(sep) && basename(item.baseDir) === skillId;
+		});
+		if (!skill) throw new ProjectSkillError("skill_not_found", 404, "Project skill not found");
+		return {
+			skill,
+			skillsRoot: location.skillsRoot
+		};
+	}
+	resolveLocation(projectId, requireWritable) {
+		const project = this.options.projects.get(projectId);
+		if (!project) throw new ProjectSkillError("project_not_found", 404, "Project not found");
+		const configuredRoot = project.workspaceRoot?.trim();
+		if (!configuredRoot) throw new ProjectSkillError("project_workspace_required", 409, "Project workspace is required");
+		const workspaceRoot = resolve(configuredRoot);
+		try {
+			if (!existsSync(workspaceRoot) || !statSync(workspaceRoot).isDirectory()) throw new ProjectSkillError("project_workspace_missing", 409, "Project workspace does not exist");
+		} catch (error) {
+			if (error instanceof ProjectSkillError) throw error;
+			throw new ProjectSkillError("project_workspace_missing", 409, "Project workspace does not exist");
+		}
+		const skillsRoot = resolveWorkspaceSkillsDir(workspaceRoot);
+		if (requireWritable) try {
+			const xopcRoot = dirname(skillsRoot);
+			accessSync(existsSync(skillsRoot) ? skillsRoot : existsSync(xopcRoot) ? xopcRoot : workspaceRoot, constants.W_OK);
+		} catch {
+			throw new ProjectSkillError("project_workspace_not_writable", 403, "Project workspace is not writable");
+		}
+		return {
+			workspaceRoot,
+			skillsRoot
+		};
+	}
+	isDirectSkill(skill, skillsRoot) {
+		const rel = relative(skillsRoot, skill.baseDir);
+		return Boolean(rel) && !rel.includes(sep) && isValidSkillId(basename(skill.baseDir));
+	}
+	toSummary(skill) {
+		return {
+			id: basename(skill.baseDir),
+			name: skill.name,
+			description: skill.description,
+			category: skill.category,
+			disableModelInvocation: skill.disableModelInvocation,
+			metadata: skill.metadata,
+			toolConditions: skill.toolConditions,
+			requiredEnvVarNames: skill.requiredEnvVarNames
+		};
+	}
+};
+//#endregion
+export { ProjectSkillError, ProjectSkillService };

package/dist/src/storage/sqlite/home-attention-repository.d.ts

@@ -0,0 +1,3 @@
+export type HomeAttentionSubjectKind = 'automation_run' | 'workflow_run';
+export declare function acknowledgeHomeAttention(subjectKind: HomeAttentionSubjectKind, subjectId: string, acknowledgedAt?: number): void;
+export declare function isHomeAttentionAcknowledged(subjectKind: HomeAttentionSubjectKind, subjectId: string): boolean;

package/dist/src/storage/sqlite/home-attention-repository.js

@@ -0,0 +1,21 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+//#region src/storage/sqlite/home-attention-repository.ts
+function acknowledgeHomeAttention(subjectKind, subjectId, acknowledgedAt = Date.now()) {
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`
+      INSERT INTO home_attention_acknowledgements (subject_kind, subject_id, acknowledged_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(subject_kind, subject_id) DO UPDATE SET
+        acknowledged_at = excluded.acknowledged_at
+    `).run(subjectKind, subjectId, acknowledgedAt);
+	});
+}
+function isHomeAttentionAcknowledged(subjectKind, subjectId) {
+	return getSqliteDatabase().prepare(`
+      SELECT 1
+      FROM home_attention_acknowledgements
+      WHERE subject_kind = ? AND subject_id = ?
+    `).get(subjectKind, subjectId) !== void 0;
+}
+//#endregion
+export { acknowledgeHomeAttention, isHomeAttentionAcknowledged };

package/dist/src/storage/sqlite/index.d.ts

@@ -5,6 +5,7 @@ export { DatabaseSchemaMigrationGapError, DatabaseSchemaTooNewError, } from './m
 export { discoverSqlMigrations, listRegisteredMigrationTargets } from './migrations/discover.js';
 export { closeXopcDatabase, getXopcDatabase, isXopcDatabaseOpen, openXopcDatabase, requireXopcDatabase, resetXopcDatabaseSingletonForTest, type OpenXopcDatabaseOptions, type XopcDatabase, } from './connection.js';
 export { getSqliteDatabase, runSqliteWriteTransaction } from './transaction.js';
+export { acknowledgeHomeAttention, isHomeAttentionAcknowledged, type HomeAttentionSubjectKind, } from './home-attention-repository.js';
 export { getUserClaim, linkUserClaimMemoryRecord, listUserClaimEvidence, listUserClaimStatsBySource, listUserClaims, listUserPeopleGraphRows, removeUserClaimEvidenceForSource, reinforceUserClaim, resolveUserEntity, setUserClaimDecision, type UserClaim, type UserClaimClass, type UserClaimState, type UserEntity, } from './user-claims-repository.js';
 export { claimNextConnectorLearningJob, enqueueConnectorLearningJob, listConnectorLearningJobs, recoverStaleConnectorLearningJobs, setConnectorLearningPaused, updateConnectorLearningJob, type ConnectorLearningJob, type ConnectorLearningMode, type ConnectorLearningPhase, type ConnectorLearningStatus, } from './connector-learning-repository.js';
 export { appendComposerInputHistory, clearComposerInputHistory, listComposerInputHistory, COMPOSER_INPUT_HISTORY_LIMIT, type ComposerInputHistoryItem, } from './composer-input-history-repository.js';