@tanstack/intent 0.0.32 → 0.0.34

package/dist/index.mjs

@@ -1,12 +1,14 @@
 import { a as parseFrontmatter, n as findSkillFiles, o as resolveDepDir, r as getDeps } from "./utils-COlDcU72.mjs";
 import "./skill-paths-8k9K9y26.mjs";
-import { t as scanForIntents } from "./scanner-DKL8v8is.mjs";
-import "./workspace-patterns-U35B5AO-.mjs";
-import { t as checkStaleness } from "./staleness-DorwfGrf.mjs";
-import { i as parseSkillUse, n as formatSkillUse, r as isSkillUseParseError, t as SkillUseParseError } from "./skill-use-CXOnncWK.mjs";
-import { n as isResolveSkillUseError, r as resolveSkillUse, t as ResolveSkillUseError } from "./resolver-aFigTqXi.mjs";
-import "./project-context-CKG-q4rD.mjs";
-import { r as runSetupGithubActions, t as runEditPackageJson } from "./setup-JJvjiGkM.mjs";
+import { t as scanForIntents } from "./scanner-Dav1tzQK.mjs";
+import "./workspace-patterns-BN2A_60g.mjs";
+import { t as readIntentArtifacts } from "./artifact-coverage-wLNVX8yC.mjs";
+import { n as checkStaleness } from "./staleness-PdgakrCQ.mjs";
+import { n as collectStaleReviewItems, r as createFailedStaleReviewItem, t as buildStaleReviewBody } from "./workflow-review-CwkPVIQf.mjs";
+import { i as parseSkillUse, n as formatSkillUse, r as isSkillUseParseError, t as SkillUseParseError } from "./skill-use-BzuuvLM7.mjs";
+import { n as isResolveSkillUseError, r as resolveSkillUse, t as ResolveSkillUseError } from "./resolver-Whd12ksO.mjs";
+import "./project-context-alYMNoNa.mjs";
+import { r as runSetupGithubActions, t as runEditPackageJson } from "./setup-Dp-W8y0Y.mjs";
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { execFileSync, execSync } from "node:child_process";
@@ -274,4 +276,4 @@ function submitMetaFeedback(payload, opts) {
 }
 
 //#endregion
-export { ResolveSkillUseError, SkillUseParseError, checkStaleness, containsSecrets, findSkillFiles, formatSkillUse, getDeps, hasGhCli, isResolveSkillUseError, isSkillUseParseError, metaToMarkdown, parseFrontmatter, parseSkillUse, resolveDepDir, resolveFrequency, resolveSkillUse, runEditPackageJson, runSetupGithubActions, scanForIntents, submitFeedback, submitMetaFeedback, toMarkdown, validateMetaPayload, validatePayload };
+export { ResolveSkillUseError, SkillUseParseError, buildStaleReviewBody, checkStaleness, collectStaleReviewItems, containsSecrets, createFailedStaleReviewItem, findSkillFiles, formatSkillUse, getDeps, hasGhCli, isResolveSkillUseError, isSkillUseParseError, metaToMarkdown, parseFrontmatter, parseSkillUse, readIntentArtifacts, resolveDepDir, resolveFrequency, resolveSkillUse, runEditPackageJson, runSetupGithubActions, scanForIntents, submitFeedback, submitMetaFeedback, toMarkdown, validateMetaPayload, validatePayload };

package/dist/{install-BmVqcbEi.mjs → install-QjryhQtg.mjs}

@@ -1,5 +1,5 @@
-import { i as parseSkillUse, n as formatSkillUse } from "./skill-use-CXOnncWK.mjs";
-import { t as resolveProjectContext } from "./project-context-CKG-q4rD.mjs";
+import { i as parseSkillUse, n as formatSkillUse } from "./skill-use-BzuuvLM7.mjs";
+import { t as resolveProjectContext } from "./project-context-alYMNoNa.mjs";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { parse } from "yaml";
@@ -28,11 +28,25 @@ function printWarnings(warnings) {
 
 //#endregion
 //#region src/cli-support.ts
+const INTENT_CHECK_SKILLS_WORKFLOW_VERSION = 3;
 function getMetaDir() {
 	return join(dirname(fileURLToPath(import.meta.url)), "..", "meta");
 }
+function getCheckSkillsWorkflowAdvisories(root) {
+	const workflowPath = join(root, ".github", "workflows", "check-skills.yml");
+	if (!existsSync(workflowPath)) return [];
+	let content;
+	try {
+		content = readFileSync(workflowPath, "utf8");
+	} catch {
+		return [];
+	}
+	const versionMatch = content.match(/intent-workflow-version:\s*(\d+)/);
+	if ((versionMatch ? Number(versionMatch[1]) : 0) >= INTENT_CHECK_SKILLS_WORKFLOW_VERSION) return [];
+	return [`Intent workflow update available: run \`npx @tanstack/intent@latest setup\` to refresh ${relative(process.cwd(), workflowPath) || workflowPath}.`];
+}
 async function scanIntentsOrFail(options) {
-	const { scanForIntents } = await import("./scanner-CRZITpcY.mjs");
+	const { scanForIntents } = await import("./scanner-BAZxWeUk.mjs");
 	try {
 		return scanForIntents(void 0, options);
 	} catch (err) {
@@ -45,31 +59,53 @@ function scanOptionsFromGlobalFlags(options) {
 	if (options.global) return { scope: "local-and-global" };
 	return { scope: "local" };
 }
-function readPackageName(root) {
-	try {
-		const pkgJson = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
-		return typeof pkgJson.name === "string" ? pkgJson.name : relative(process.cwd(), root) || "unknown";
-	} catch {
-		return relative(process.cwd(), root) || "unknown";
-	}
-}
 async function resolveStaleTargets(targetDir) {
 	const resolvedRoot = targetDir ? resolve(process.cwd(), targetDir) : process.cwd();
 	const context = resolveProjectContext({
 		cwd: process.cwd(),
 		targetPath: targetDir
 	});
-	const { checkStaleness } = await import("./staleness-NF-lxfXf.mjs");
-	if (context.packageRoot && (context.targetSkillsDir !== null || resolvedRoot !== context.workspaceRoot)) return { reports: [await checkStaleness(context.packageRoot, readPackageName(context.packageRoot))] };
-	if (existsSync(join(resolvedRoot, "skills"))) return { reports: [await checkStaleness(resolvedRoot, readPackageName(resolvedRoot))] };
-	const { findPackagesWithSkills, findWorkspaceRoot } = await import("./workspace-patterns-DbnA0peB.mjs");
+	const workflowAdvisories = getCheckSkillsWorkflowAdvisories(context.workspaceRoot ?? context.packageRoot ?? resolvedRoot);
+	const { buildWorkspaceCoverageSignals, checkStaleness, readPackageName } = await import("./staleness-DpbmYod4.mjs");
+	const isWorkspaceRootTarget = context.workspaceRoot !== null && resolvedRoot === context.workspaceRoot;
+	if (context.packageRoot && !isWorkspaceRootTarget && (context.targetSkillsDir !== null || context.workspaceRoot === null)) return {
+		reports: [await checkStaleness(context.packageRoot, readPackageName(context.packageRoot), context.workspaceRoot ?? context.packageRoot)],
+		workflowAdvisories
+	};
+	const { findPackagesWithSkills, findWorkspacePackages, findWorkspaceRoot } = await import("./workspace-patterns-x-dLZxx4.mjs");
 	const workspaceRoot = findWorkspaceRoot(resolvedRoot);
 	if (workspaceRoot) {
-		const packageDirs = findPackagesWithSkills(workspaceRoot);
-		if (packageDirs.length > 0) return { reports: await Promise.all(packageDirs.map((packageDir) => checkStaleness(packageDir, readPackageName(packageDir)))) };
+		const packageDirsWithSkills = findPackagesWithSkills(workspaceRoot);
+		const allPackageDirs = findWorkspacePackages(workspaceRoot);
+		const reports = await Promise.all(packageDirsWithSkills.map((packageDir) => checkStaleness(packageDir, readPackageName(packageDir), workspaceRoot)));
+		const { readIntentArtifacts } = await import("./artifact-coverage-BAN2W6aH.mjs");
+		const coverageSignals = buildWorkspaceCoverageSignals({
+			artifactRoot: workspaceRoot,
+			artifacts: existsSync(join(workspaceRoot, "_artifacts")) ? readIntentArtifacts(workspaceRoot) : null,
+			packageDirs: allPackageDirs
+		});
+		if (coverageSignals.length > 0) reports.push({
+			library: relative(process.cwd(), workspaceRoot) || "workspace",
+			currentVersion: null,
+			skillVersion: null,
+			versionDrift: null,
+			skills: [],
+			signals: coverageSignals
+		});
+		if (reports.length > 0) return {
+			reports,
+			workflowAdvisories
+		};
 	}
+	if (existsSync(join(resolvedRoot, "skills"))) return {
+		reports: [await checkStaleness(resolvedRoot, readPackageName(resolvedRoot))],
+		workflowAdvisories
+	};
 	const staleResult = await scanIntentsOrFail();
-	return { reports: await Promise.all(staleResult.packages.map((pkg) => checkStaleness(pkg.packageRoot, pkg.name))) };
+	return {
+		reports: await Promise.all(staleResult.packages.map((pkg) => checkStaleness(pkg.packageRoot, pkg.name))),
+		workflowAdvisories
+	};
 }
 
 //#endregion

package/dist/intent-library.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import "./utils-COlDcU72.mjs";
 import "./skill-paths-8k9K9y26.mjs";
-import "./workspace-patterns-U35B5AO-.mjs";
-import "./project-context-CKG-q4rD.mjs";
-import { t as INSTALL_PROMPT } from "./install-BmVqcbEi.mjs";
-import { n as printSkillTree, r as printTable, t as computeSkillNameWidth } from "./display-DUgtRJkt.mjs";
-import { t as scanLibrary } from "./library-scanner-DFFreLjW.mjs";
+import "./workspace-patterns-BN2A_60g.mjs";
+import "./project-context-alYMNoNa.mjs";
+import { t as INSTALL_PROMPT } from "./install-QjryhQtg.mjs";
+import { n as printSkillTree, r as printTable, t as computeSkillNameWidth } from "./display-CAof6doy.mjs";
+import { t as scanLibrary } from "./library-scanner-fexXlPXb.mjs";
 
 //#region src/intent-library.ts
 function cmdList() {

package/dist/library-scanner.d.mts

@@ -1,4 +1,4 @@
-import { u as SkillEntry } from "./types-CsySN6Vw.mjs";
+import { h as SkillEntry } from "./types-DT7Y6TFz.mjs";
 
 //#region src/library-scanner.d.ts
 interface LibraryPackage {

package/dist/library-scanner.mjs

@@ -1,5 +1,5 @@
 import "./utils-COlDcU72.mjs";
 import "./skill-paths-8k9K9y26.mjs";
-import { t as scanLibrary } from "./library-scanner-DFFreLjW.mjs";
+import { t as scanLibrary } from "./library-scanner-fexXlPXb.mjs";
 
 export { scanLibrary };

package/dist/{project-context-CKG-q4rD.mjs → project-context-alYMNoNa.mjs}

@@ -1,4 +1,4 @@
-import { n as findWorkspaceRoot, r as readWorkspacePatterns } from "./workspace-patterns-U35B5AO-.mjs";
+import { i as readWorkspacePatterns, r as findWorkspaceRoot } from "./workspace-patterns-BN2A_60g.mjs";
 import { existsSync, statSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 

package/dist/{resolver-aFigTqXi.mjs → resolver-Whd12ksO.mjs}

@@ -1,4 +1,4 @@
-import { i as parseSkillUse } from "./skill-use-CXOnncWK.mjs";
+import { i as parseSkillUse } from "./skill-use-BzuuvLM7.mjs";
 
 //#region src/resolver.ts
 var ResolveSkillUseError = class extends Error {

package/dist/scanner-BAZxWeUk.mjs

@@ -0,0 +1,6 @@
+import "./utils-COlDcU72.mjs";
+import "./skill-paths-8k9K9y26.mjs";
+import { t as scanForIntents } from "./scanner-Dav1tzQK.mjs";
+import "./workspace-patterns-BN2A_60g.mjs";
+
+export { scanForIntents };

package/dist/{scanner-DKL8v8is.mjs → scanner-Dav1tzQK.mjs}

@@ -1,8 +1,9 @@
 import { a as parseFrontmatter, i as listNodeModulesPackageDirs, o as resolveDepDir, r as getDeps, s as toPosixPath, t as detectGlobalNodeModules } from "./utils-COlDcU72.mjs";
 import { r as rewriteSkillLoadPaths } from "./skill-paths-8k9K9y26.mjs";
-import { i as resolveWorkspacePackages, n as findWorkspaceRoot, r as readWorkspacePatterns } from "./workspace-patterns-U35B5AO-.mjs";
+import { a as resolveWorkspacePackages, i as readWorkspacePatterns, r as findWorkspaceRoot } from "./workspace-patterns-BN2A_60g.mjs";
+import { createRequire } from "node:module";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { join, relative, sep } from "node:path";
+import { dirname, join, relative, resolve, sep } from "node:path";
 
 //#region src/discovery/register.ts
 function isLocalToProject(dirPath, projectRoot) {
@@ -132,13 +133,31 @@ function createDependencyWalker(opts) {
 
 //#endregion
 //#region src/scanner.ts
-function detectPackageManager(root) {
-	if (existsSync(join(root, ".pnp.cjs")) || existsSync(join(root, ".pnp.js"))) throw new Error("Yarn PnP is not yet supported. Add `nodeLinker: node-modules` to your .yarnrc.yml to use intent.");
+const requireFromHere = createRequire(import.meta.url);
+function findPnpFile(start) {
+	let dir = resolve(start);
+	while (true) {
+		for (const fileName of [".pnp.cjs", ".pnp.js"]) {
+			const pnpPath = join(dir, fileName);
+			if (existsSync(pnpPath)) return pnpPath;
+		}
+		const next = dirname(dir);
+		if (next === dir) return null;
+		dir = next;
+	}
+}
+function isYarnPnpProject(root) {
+	return findPnpFile(root) !== null;
+}
+function assertLocalNodeModulesSupported(root) {
 	if (existsSync(join(root, "deno.json")) && !existsSync(join(root, "node_modules"))) throw new Error("Deno without node_modules is not yet supported. Add `\"nodeModulesDir\": \"auto\"` to your deno.json to use intent.");
+}
+function detectPackageManager(root) {
 	const dirsToCheck = [root];
 	const wsRoot = findWorkspaceRoot(root);
 	if (wsRoot && wsRoot !== root) dirsToCheck.push(wsRoot);
 	for (const dir of dirsToCheck) {
+		if (isYarnPnpProject(dir)) return "yarn";
 		if (existsSync(join(dir, "pnpm-lock.yaml"))) return "pnpm";
 		if (existsSync(join(dir, "bun.lockb")) || existsSync(join(dir, "bun.lock"))) return "bun";
 		if (existsSync(join(dir, "yarn.lock"))) return "yarn";
@@ -146,6 +165,35 @@ function detectPackageManager(root) {
 	}
 	return "unknown";
 }
+function loadPnpApi(root) {
+	const pnpPath = findPnpFile(root);
+	if (!pnpPath) return null;
+	try {
+		const foundApi = requireFromHere("node:module").findPnpApi?.(root);
+		if (foundApi) return foundApi;
+		const pnpModule = requireFromHere(pnpPath);
+		if (typeof pnpModule.setup === "function") pnpModule.setup();
+		if (typeof pnpModule.getDependencyTreeRoots === "function" && typeof pnpModule.getPackageInformation === "function") return pnpModule;
+		return createRequire(join(dirname(pnpPath), "package.json"))("pnpapi");
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		throw new Error(`Yarn PnP project detected, but Intent could not load Yarn's PnP API from ${pnpPath}: ${msg}`);
+	}
+}
+function getPnpLocatorKey(locator) {
+	return `${locator.name ?? "<top>"}@${locator.reference ?? "<top>"}`;
+}
+function getPnpDependencyLocator(dependencyName, target) {
+	if (target === null) return null;
+	if (Array.isArray(target)) return {
+		name: target[0],
+		reference: target[1]
+	};
+	return {
+		name: dependencyName,
+		reference: target
+	};
+}
 function validateIntentField(_pkgName, intent) {
 	if (!intent || typeof intent !== "object") return null;
 	const pb = intent;
@@ -304,6 +352,7 @@ function scanForIntents(root, options = {}) {
 	const projectRoot = root ?? process.cwd();
 	const scanScope = getScanScope(options);
 	const packageManager = detectPackageManager(projectRoot);
+	const pnpApi = scanScope === "global" ? null : loadPnpApi(projectRoot);
 	const nodeModulesDir = join(projectRoot, "node_modules");
 	const explicitGlobalNodeModules = process.env.INTENT_GLOBAL_NODE_MODULES?.trim() || null;
 	const packages = [];
@@ -378,7 +427,33 @@ function scanForIntents(root, options = {}) {
 		tryRegister,
 		warnings
 	});
+	function scanPnpPackages() {
+		if (!pnpApi) return;
+		const api = pnpApi;
+		const visited = /* @__PURE__ */ new Set();
+		const workspaceRoot = findWorkspaceRoot(projectRoot);
+		const projectLocator = api.findPackageLocator?.(projectRoot.endsWith(sep) ? projectRoot : `${projectRoot}${sep}`);
+		const roots = workspaceRoot && workspaceRoot !== projectRoot && projectLocator ? [projectLocator] : api.getDependencyTreeRoots?.() ?? (api.topLevel ? [api.topLevel] : []);
+		function visit(locator) {
+			const key = getPnpLocatorKey(locator);
+			if (visited.has(key)) return;
+			visited.add(key);
+			const info = api.getPackageInformation(locator);
+			if (!info) return;
+			tryRegister(info.packageLocation.replace(/[\\/]$/, ""), locator.name ?? "unknown");
+			for (const [dependencyName, target] of info.packageDependencies) {
+				const dependencyLocator = getPnpDependencyLocator(dependencyName, target);
+				if (dependencyLocator) visit(dependencyLocator);
+			}
+		}
+		for (const locator of roots) visit(locator);
+	}
 	function scanLocalPackages() {
+		if (pnpApi && !nodeModules.local.exists) {
+			scanPnpPackages();
+			return;
+		}
+		assertLocalNodeModulesSupported(projectRoot);
 		scanTarget(nodeModules.local);
 		walkWorkspacePackages();
 		walkKnownPackages();

package/dist/{setup-JJvjiGkM.mjs → setup-Dp-W8y0Y.mjs}

@@ -1,5 +1,5 @@
-import { n as findWorkspaceRoot, r as readWorkspacePatterns, t as findPackagesWithSkills } from "./workspace-patterns-U35B5AO-.mjs";
-import { t as resolveProjectContext } from "./project-context-CKG-q4rD.mjs";
+import { i as readWorkspacePatterns, r as findWorkspaceRoot, t as findPackagesWithSkills } from "./workspace-patterns-BN2A_60g.mjs";
+import { t as resolveProjectContext } from "./project-context-alYMNoNa.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { basename, join, relative } from "node:path";
 

package/dist/setup.d.mts

@@ -1,2 +1,2 @@
-import { a as runEditPackageJsonAll, c as findWorkspaceRoot, i as runEditPackageJson, l as readWorkspacePatterns, n as MonorepoResult, o as runSetupGithubActions, r as SetupGithubActionsResult, s as findPackagesWithSkills, t as EditPackageJsonResult, u as resolveWorkspacePackages } from "./setup-DDoOLriA.mjs";
+import { a as runEditPackageJsonAll, c as findWorkspaceRoot, i as runEditPackageJson, l as readWorkspacePatterns, n as MonorepoResult, o as runSetupGithubActions, r as SetupGithubActionsResult, s as findPackagesWithSkills, t as EditPackageJsonResult, u as resolveWorkspacePackages } from "./setup-t1i2o2-h.mjs";
 export { EditPackageJsonResult, MonorepoResult, SetupGithubActionsResult, findPackagesWithSkills, findWorkspaceRoot, readWorkspacePatterns, resolveWorkspacePackages, runEditPackageJson, runEditPackageJsonAll, runSetupGithubActions };

package/dist/setup.mjs

@@ -1,6 +1,6 @@
 import "./utils-COlDcU72.mjs";
-import { i as resolveWorkspacePackages, n as findWorkspaceRoot, r as readWorkspacePatterns, t as findPackagesWithSkills } from "./workspace-patterns-U35B5AO-.mjs";
-import "./project-context-CKG-q4rD.mjs";
-import { n as runEditPackageJsonAll, r as runSetupGithubActions, t as runEditPackageJson } from "./setup-JJvjiGkM.mjs";
+import { a as resolveWorkspacePackages, i as readWorkspacePatterns, r as findWorkspaceRoot, t as findPackagesWithSkills } from "./workspace-patterns-BN2A_60g.mjs";
+import "./project-context-alYMNoNa.mjs";
+import { n as runEditPackageJsonAll, r as runSetupGithubActions, t as runEditPackageJson } from "./setup-Dp-W8y0Y.mjs";
 
 export { findPackagesWithSkills, findWorkspaceRoot, readWorkspacePatterns, resolveWorkspacePackages, runEditPackageJson, runEditPackageJsonAll, runSetupGithubActions };

package/dist/staleness-DpbmYod4.mjs

@@ -0,0 +1,5 @@
+import "./utils-COlDcU72.mjs";
+import "./artifact-coverage-wLNVX8yC.mjs";
+import { n as checkStaleness, r as readPackageName, t as buildWorkspaceCoverageSignals } from "./staleness-PdgakrCQ.mjs";
+
+export { buildWorkspaceCoverageSignals, checkStaleness, readPackageName };

package/dist/staleness-PdgakrCQ.mjs

@@ -0,0 +1,243 @@
+import { a as parseFrontmatter, n as findSkillFiles } from "./utils-COlDcU72.mjs";
+import { t as readIntentArtifacts } from "./artifact-coverage-wLNVX8yC.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+
+//#region src/staleness.ts
+function classifyVersionDrift(oldVer, newVer) {
+	if (oldVer === newVer) return null;
+	const oldParts = oldVer.replace(/[^0-9.]/g, "").split(".").map(Number);
+	const newParts = newVer.replace(/[^0-9.]/g, "").split(".").map(Number);
+	if ((newParts[0] ?? 0) > (oldParts[0] ?? 0)) return "major";
+	if ((newParts[1] ?? 0) > (oldParts[1] ?? 0)) return "minor";
+	if ((newParts[2] ?? 0) > (oldParts[2] ?? 0)) return "patch";
+	return null;
+}
+function readLocalVersion(packageDir) {
+	try {
+		const pkgJson = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8"));
+		return typeof pkgJson.version === "string" ? pkgJson.version : null;
+	} catch {
+		return null;
+	}
+}
+async function fetchNpmVersion(packageName) {
+	try {
+		const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`);
+		if (!res.ok) return null;
+		const data = await res.json();
+		return typeof data.version === "string" ? data.version : null;
+	} catch {
+		return null;
+	}
+}
+async function fetchCurrentVersion(packageDir, packageName) {
+	return readLocalVersion(packageDir) ?? await fetchNpmVersion(packageName);
+}
+function isStringRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function parseSyncState(value) {
+	if (!value || typeof value !== "object") return null;
+	const raw = value;
+	const parsed = {};
+	if (typeof raw.library_version === "string") parsed.library_version = raw.library_version;
+	if (raw.skills && typeof raw.skills === "object") {
+		const skills = {};
+		for (const [skillName, skillValue] of Object.entries(raw.skills)) {
+			if (!skillValue || typeof skillValue !== "object") continue;
+			const sourcesSha = skillValue.sources_sha;
+			if (sourcesSha !== void 0 && !isStringRecord(sourcesSha)) continue;
+			skills[skillName] = {};
+			if (sourcesSha) skills[skillName].sources_sha = sourcesSha;
+		}
+		parsed.skills = skills;
+	}
+	return parsed;
+}
+function readSyncState(packageDir) {
+	const statePath = join(packageDir, "skills", "sync-state.json");
+	try {
+		return parseSyncState(JSON.parse(readFileSync(statePath, "utf8")));
+	} catch {
+		return null;
+	}
+}
+function readPackageName(packageDir) {
+	const packageJson = readPackageJson(packageDir);
+	return typeof packageJson?.name === "string" ? packageJson.name : relative(process.cwd(), packageDir) || "unknown";
+}
+function readPackageJson(packageDir) {
+	try {
+		return JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8"));
+	} catch {
+		return null;
+	}
+}
+function normalizeFilePath(path) {
+	return resolve(path).split(sep).join("/");
+}
+function normalizeList(values) {
+	return [...new Set(values ?? [])].sort((a, b) => a.localeCompare(b));
+}
+function sameStringList(a, b) {
+	const left = normalizeList(a);
+	const right = normalizeList(b);
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function artifactPackageMatches(artifact, packageDir, packageName, artifactRoot) {
+	const relPackageDir = relative(artifactRoot, packageDir).split(sep).join("/");
+	if (!relPackageDir) return true;
+	if (artifact.packages.includes(packageName)) return true;
+	if (artifact.packages.includes(relPackageDir)) return true;
+	if (artifact.path?.startsWith(`${relPackageDir}/`)) return true;
+	return artifact.packages.length === 0 && artifact.path === void 0;
+}
+function resolveArtifactSkillPaths(artifact, packageDir, artifactRoot) {
+	if (!artifact.path) return [];
+	const candidatePaths = [isAbsolute(artifact.path) ? artifact.path : join(artifactRoot, artifact.path), isAbsolute(artifact.path) ? artifact.path : join(packageDir, artifact.path)];
+	if (artifact.package && artifact.path.startsWith("skills/")) candidatePaths.push(join(artifactRoot, artifact.package, artifact.path));
+	return [...new Set(candidatePaths.map(normalizeFilePath))];
+}
+function findMatchingSkill(artifact, skillMetas, packageDir, artifactRoot) {
+	const skillsByPath = new Map(skillMetas.map((skill) => [normalizeFilePath(skill.filePath), skill]));
+	for (const candidatePath of resolveArtifactSkillPaths(artifact, packageDir, artifactRoot)) {
+		const match = skillsByPath.get(candidatePath);
+		if (match) return match;
+	}
+	const skillsByName = /* @__PURE__ */ new Map();
+	for (const skill of skillMetas) {
+		skillsByName.set(skill.name, skill);
+		skillsByName.set(skill.relName, skill);
+	}
+	return (artifact.slug ? skillsByName.get(artifact.slug) : void 0) ?? (artifact.name ? skillsByName.get(artifact.name) : void 0) ?? null;
+}
+function buildArtifactSignals({ artifactRoot, artifacts, library, packageDir, skillMetas }) {
+	if (!artifacts) return [];
+	const artifactFiles = new Map([...artifacts.skillTrees, ...artifacts.domainMaps].map((file) => [file.path, file]));
+	const signals = artifacts.warnings.map((warning) => ({
+		type: "artifact-parse-warning",
+		library,
+		subject: warning.artifactPath,
+		reasons: [warning.message],
+		needsReview: true,
+		artifactPath: warning.artifactPath
+	}));
+	for (const artifact of artifacts.skills) {
+		if (!artifactPackageMatches(artifact, packageDir, library, artifactRoot)) continue;
+		const subject = artifact.slug ?? artifact.name ?? artifact.path;
+		const matchingSkill = findMatchingSkill(artifact, skillMetas, packageDir, artifactRoot);
+		if (artifact.path && !matchingSkill) {
+			signals.push({
+				type: "artifact-skill-missing",
+				library,
+				subject,
+				reasons: [`artifact skill path does not resolve to a generated SKILL.md (${artifact.path})`],
+				needsReview: true,
+				artifactPath: artifact.artifactPath,
+				skill: artifact.slug ?? artifact.name
+			});
+			continue;
+		}
+		if (!matchingSkill) continue;
+		if (matchingSkill.sources !== void 0 && artifact.sources.length > 0 && !sameStringList(matchingSkill.sources, artifact.sources)) signals.push({
+			type: "artifact-source-drift",
+			library,
+			subject,
+			reasons: ["artifact sources differ from SKILL.md frontmatter sources"],
+			needsReview: true,
+			artifactPath: artifact.artifactPath,
+			skill: matchingSkill.name
+		});
+		const artifactVersion = artifactFiles.get(artifact.artifactPath)?.libraryVersion;
+		if (artifactVersion && matchingSkill.libraryVersion && artifactVersion !== matchingSkill.libraryVersion) signals.push({
+			type: "artifact-library-version-drift",
+			library,
+			subject,
+			reasons: [`artifact library.version (${artifactVersion}) differs from SKILL.md library_version (${matchingSkill.libraryVersion})`],
+			needsReview: true,
+			artifactPath: artifact.artifactPath,
+			skill: matchingSkill.name
+		});
+	}
+	return signals;
+}
+function artifactCoversPackage(artifact, packageDir, packageName, artifactRoot) {
+	const relPackageDir = relative(artifactRoot, packageDir).split(sep).join("/");
+	return artifact.packages.includes(packageName) || artifact.packages.includes(relPackageDir) || artifact.package === packageName || artifact.package === relPackageDir || artifact.path?.startsWith(`${relPackageDir}/`) === true;
+}
+function artifactIgnoresPackage(artifacts, packageDir, packageName, artifactRoot) {
+	const relPackageDir = relative(artifactRoot, packageDir).split(sep).join("/");
+	return artifacts.ignoredPackages.some((ignored) => ignored.packageName === packageName || ignored.packageName === relPackageDir);
+}
+function buildWorkspaceCoverageSignals({ artifactRoot, artifacts, packageDirs }) {
+	if (!artifacts) return [];
+	const signals = [];
+	for (const packageDir of packageDirs) {
+		if (readPackageJson(packageDir)?.private === true) continue;
+		const packageName = readPackageName(packageDir);
+		if (artifactIgnoresPackage(artifacts, packageDir, packageName, artifactRoot)) continue;
+		const hasGeneratedSkill = findSkillFiles(join(packageDir, "skills")).length > 0;
+		const hasArtifactCoverage = artifacts.skills.some((artifact) => artifactCoversPackage(artifact, packageDir, packageName, artifactRoot));
+		if (hasGeneratedSkill || hasArtifactCoverage) continue;
+		signals.push({
+			type: "missing-package-coverage",
+			library: packageName,
+			subject: packageName,
+			reasons: ["workspace package is not represented by generated skills or _artifacts coverage"],
+			needsReview: true,
+			packageName,
+			packageRoot: relative(artifactRoot, packageDir).split(sep).join("/")
+		});
+	}
+	return signals;
+}
+async function checkStaleness(packageDir, packageName, artifactRoot = packageDir) {
+	const skillsDir = join(packageDir, "skills");
+	const library = packageName ?? "unknown";
+	const skillMetas = findSkillFiles(skillsDir).map((filePath) => {
+		const fm = parseFrontmatter(filePath);
+		const relName = relative(skillsDir, filePath).replace(/[/\\]SKILL\.md$/, "").split(sep).join("/");
+		return {
+			name: typeof fm?.name === "string" ? fm.name : relName,
+			relName,
+			filePath,
+			libraryVersion: fm?.library_version,
+			sources: Array.isArray(fm?.sources) ? fm.sources : void 0
+		};
+	});
+	const artifacts = existsSync(join(artifactRoot, "_artifacts")) ? readIntentArtifacts(artifactRoot) : null;
+	const skillVersion = skillMetas.find((s) => s.libraryVersion)?.libraryVersion ?? null;
+	const currentVersion = await fetchCurrentVersion(packageDir, library);
+	const versionDrift = skillVersion && currentVersion ? classifyVersionDrift(skillVersion, currentVersion) : null;
+	const syncState = readSyncState(packageDir);
+	return {
+		library,
+		currentVersion,
+		skillVersion,
+		versionDrift,
+		skills: skillMetas.map((skill) => {
+			const reasons = [];
+			if (currentVersion && skill.libraryVersion && skill.libraryVersion !== currentVersion) reasons.push(`version drift (${skill.libraryVersion} → ${currentVersion})`);
+			const storedShas = syncState?.skills?.[skill.name]?.sources_sha ?? {};
+			if (skill.sources && Object.keys(storedShas).length > 0) {
+				for (const source of skill.sources) if (!storedShas[source]) reasons.push(`new source (${source})`);
+			}
+			return {
+				name: skill.name,
+				reasons,
+				needsReview: reasons.length > 0
+			};
+		}),
+		signals: buildArtifactSignals({
+			artifactRoot,
+			artifacts,
+			library,
+			packageDir,
+			skillMetas
+		})
+	};
+}
+
+//#endregion
+export { checkStaleness as n, readPackageName as r, buildWorkspaceCoverageSignals as t };

package/dist/{types-CsySN6Vw.d.mts → types-DT7Y6TFz.d.mts}

@@ -57,12 +57,59 @@ interface StalenessReport {
   skillVersion: string | null;
   versionDrift: 'major' | 'minor' | 'patch' | null;
   skills: Array<SkillStaleness>;
+  signals: Array<StalenessSignal>;
 }
 interface SkillStaleness {
   name: string;
   reasons: Array<string>;
   needsReview: boolean;
 }
+interface StalenessSignal {
+  type: string;
+  library?: string;
+  subject?: string;
+  reasons: Array<string>;
+  needsReview: boolean;
+  artifactPath?: string;
+  packageName?: string;
+  packageRoot?: string;
+  skill?: string;
+}
+interface IntentArtifactSet {
+  root: string;
+  artifactsDir: string;
+  skillTrees: Array<IntentArtifactFile>;
+  domainMaps: Array<IntentArtifactFile>;
+  skills: Array<IntentArtifactSkill>;
+  ignoredPackages: Array<IntentArtifactCoverageIgnore>;
+  warnings: Array<IntentArtifactWarning>;
+}
+interface IntentArtifactFile {
+  path: string;
+  kind: 'skill-tree' | 'domain-map';
+  libraryName?: string;
+  libraryVersion?: string;
+}
+interface IntentArtifactSkill {
+  artifactPath: string;
+  artifactKind: 'skill-tree' | 'domain-map';
+  name?: string;
+  slug?: string;
+  path?: string;
+  package?: string;
+  packages: Array<string>;
+  sources: Array<string>;
+  covers: Array<string>;
+}
+interface IntentArtifactCoverageIgnore {
+  packageName: string;
+  reason?: string;
+  artifactPath: string;
+}
+interface IntentArtifactWarning {
+  artifactPath: string;
+  message: string;
+}
 interface FeedbackPayload {
   skill: string;
   package: string;
@@ -96,4 +143,4 @@ interface IntentProjectConfig {
   };
 }
 //#endregion
-export { IntentProjectConfig as a, ScanOptions as c, SkillStaleness as d, StalenessReport as f, IntentPackage as i, ScanResult as l, FeedbackPayload as n, MetaFeedbackPayload as o, VersionConflict as p, IntentConfig as r, MetaSkillName as s, AgentName as t, SkillEntry as u };
+export { StalenessReport as _, IntentArtifactSet as a, IntentConfig as c, MetaFeedbackPayload as d, MetaSkillName as f, SkillStaleness as g, SkillEntry as h, IntentArtifactFile as i, IntentPackage as l, ScanResult as m, FeedbackPayload as n, IntentArtifactSkill as o, ScanOptions as p, IntentArtifactCoverageIgnore as r, IntentArtifactWarning as s, AgentName as t, IntentProjectConfig as u, StalenessSignal as v, VersionConflict as y };