@skaile/workspaces 5.19.0 → 6.1.0

package/dist/{chunk-ZQSOJH6I.js → chunk-IHFGPHCT.js}

@@ -1,256 +1,24 @@
-import { registeredAssetKeys, unresolvedManifestDependencies, warnIgnoredDomainFiles, warnLegacyBundleFiles, removedDomainOption, rejectRemovedDomainOption, reportLibrarySymlinks, composeRefContext, assetEntryRef, manifestPublisherProblems, manifestRootProblems, manifestEntryNameProblems, manifestRequiresProblems, findEntryManifestFile, declaredVersion, manifestVersionMismatchMessage, checkAsset, invalidPublisherMessage, invalidSemverText } from './chunk-WOIRYY5L.js';
-import { AI_RESOURCES } from './chunk-2PBSAH3Z.js';
-import { logErr, logInfo, logWarn, logOk } from './chunk-QG6GHTRM.js';
-import { getKindRegistry } from './chunk-F6AA42GW.js';
-import { validateFlowVersions } from './chunk-FKU57Q5Q.js';
-import { loadFlow } from './chunk-IF6IA3PZ.js';
+import { checkAgentInstances, unknownKeyWarnings, unknownHarnessErrors } from './chunk-7HX6FNKL.js';
+import { registeredAssetKeys, unresolvedManifestDependencies, warnIgnoredDomainFiles, warnLegacyBundleFiles, removedDomainOption, rejectRemovedDomainOption, reportLibrarySymlinks, composeRefContext, assetEntryRef, manifestPublisherProblems, manifestRootProblems, manifestFilesProblems, manifestEntryNameProblems, manifestRequiresProblems, checkAssetFile, findEntryManifestFile, declaredVersion, manifestVersionMismatchMessage, MANIFEST_GLOBS, manifestParseErrorText, checkAsset, invalidPublisherMessage, invalidSemverText } from './chunk-AITJ7ELM.js';
+import { AI_RESOURCES } from './chunk-AATHJRKL.js';
+import { logErr, logInfo, logWarn, logOk } from './chunk-QEULL4Q3.js';
+import { getKindRegistry } from './chunk-COYF6IG2.js';
+import { validateFlowVersions } from './chunk-IRYKRKVQ.js';
+import { loadFlow } from './chunk-4MUDQCBP.js';
 import { flowSkillVersionPins } from './chunk-7RGTAEG6.js';
-import { missingRootAssets, assertManifestEditable, scanUnlistedAssets, UNLISTED_SCAN_SKIP_DIRS } from './chunk-XM6T2AZ2.js';
-import { parseManifestFile } from './chunk-I37INEWE.js';
-import { resolveRuntimeAssets } from './chunk-TIIXG3PN.js';
-import { decodeSkaileYaml, normalizeAgentInstances, agentBlockKeyDiagnostics, agentInstanceDiagnostics, localConnectorMountDir, symlinkEscapeOfProject, isInsideProject, resolveAgentDefinitionDir, AgentRefResolutionError } from './chunk-V257LUBM.js';
-import { SKAILE_MANIFEST_FILENAME, loadSkPublishManifest, expandManifestFiles, isNonAssetPath } from './chunk-UQ33Y4DM.js';
-import { readAssetBody } from './chunk-GOCWM7FN.js';
-import { parseAssetRef, isValidPublisher, isValidAssetName, ASSET_NAME_HINT } from './chunk-WDXZA7QW.js';
+import { missingRootAssets, assertManifestEditable, scanUnlistedAssets, UNLISTED_SCAN_SKIP_DIRS } from './chunk-S2XHGWQC.js';
+import { parseManifestFile } from './chunk-UI745XC3.js';
+import { resolveRuntimeAssets } from './chunk-ZDLUQLI6.js';
+import { decodeSkaileYaml, localConnectorMountDir, symlinkEscapeOfProject, isInsideProject } from './chunk-ZHGKAZJ7.js';
+import { SKAILE_MANIFEST_FILENAME, loadSkPublishManifest, isNonAssetPath } from './chunk-ZBHZLWV3.js';
+import { readAssetBody } from './chunk-RHN5MRQO.js';
+import { parseAssetRef, isValidPublisher, isValidAssetName, ASSET_NAME_HINT } from './chunk-LSSYC5IC.js';
 import { execFileSync } from 'child_process';
-import fs2 from 'fs';
-import path2 from 'path';
+import fs from 'fs';
+import path from 'path';
 import { Command } from 'commander';
 import { parse } from 'yaml';
 
-// cli/src/type-guards.ts
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-// cli/src/commands/validate-instances.ts
-var AGENT_MANIFEST_FILE = "agent.yaml";
-var TRIGGER_REQUIRED_FIELDS = {
-  schedule: ["cron", "prompt"],
-  webhook: ["prompt"],
-  channel: ["when"],
-  event: ["event"]
-};
-var err = (code, message, at) => ({
-  code,
-  severity: "error",
-  message,
-  path: at
-});
-function readAssetFacts(manifest) {
-  const facts = {
-    lifecycle: manifest.lifecycle,
-    hasIo: manifest.io !== void 0 && manifest.io !== null,
-    connectorSlots: [],
-    otherSlots: [],
-    triggerIds: []
-  };
-  for (const item of Array.isArray(manifest.composes) ? manifest.composes : []) {
-    if (!isRecord(item) || typeof item.id !== "string") continue;
-    (item.kind === "connector" ? facts.connectorSlots : facts.otherSlots).push(item.id);
-  }
-  for (const t of Array.isArray(manifest.triggers) ? manifest.triggers : []) {
-    if (isRecord(t) && typeof t.id === "string") facts.triggerIds.push(t.id);
-  }
-  return facts;
-}
-function loadAsset(projectDir, id, ref) {
-  const at = `agents.${id}.ref`;
-  let dir;
-  try {
-    dir = resolveAgentDefinitionDir(projectDir, ref);
-  } catch (e) {
-    if (!(e instanceof AgentRefResolutionError)) throw e;
-    return { diagnostic: err("agent_ref_unresolved", `agents.${id}: ${e.message}`, at) };
-  }
-  if (dir === void 0) {
-    return {
-      diagnostic: err(
-        "agent_ref_unresolved",
-        `agents.${id}: ref "${ref}" cannot be resolved \u2014 no ai-assets/ directory above the project`,
-        at
-      )
-    };
-  }
-  const manifestPath = path2.join(dir, AGENT_MANIFEST_FILE);
-  let text;
-  try {
-    text = fs2.readFileSync(manifestPath, "utf-8");
-  } catch {
-    return {
-      diagnostic: err(
-        "agent_ref_unresolved",
-        `agents.${id}: ref "${ref}" resolves to ${dir}, which has no ${AGENT_MANIFEST_FILE}`,
-        at
-      )
-    };
-  }
-  let manifest;
-  try {
-    manifest = parse(text);
-  } catch (e) {
-    return {
-      diagnostic: err(
-        "agent_manifest_invalid",
-        `agents.${id}: ${manifestPath} is not valid YAML: ${e instanceof Error ? e.message : String(e)}`,
-        at
-      )
-    };
-  }
-  if (!isRecord(manifest)) {
-    return {
-      diagnostic: err(
-        "agent_manifest_invalid",
-        `agents.${id}: ${manifestPath} is not a mapping`,
-        at
-      )
-    };
-  }
-  return { facts: readAssetFacts(manifest) };
-}
-function checkTriggers(id, triggers, assetTriggerIds) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  triggers.forEach((trigger, i) => {
-    const at = `agents.${id}.triggers[${i}]`;
-    if (seen.has(trigger.id)) {
-      out.push(
-        err(
-          "agent_trigger_duplicate",
-          `agents.${id}: trigger id "${trigger.id}" is declared twice`,
-          `${at}.id`
-        )
-      );
-      return;
-    }
-    seen.add(trigger.id);
-    if (!assetTriggerIds || assetTriggerIds.includes(trigger.id)) return;
-    if (!trigger.kind) {
-      out.push(
-        err(
-          "agent_trigger_unknown",
-          `agents.${id}: trigger "${trigger.id}" is not declared by the agent asset (${assetTriggerIds.length > 0 ? `has: ${assetTriggerIds.join(", ")}` : "it declares no triggers"}) \u2014 add \`kind\` and the trigger's fields to declare a new one`,
-          `${at}.id`
-        )
-      );
-      return;
-    }
-    const missing = TRIGGER_REQUIRED_FIELDS[trigger.kind].filter(
-      (field) => trigger[field] === void 0
-    );
-    if (missing.length > 0) {
-      out.push(
-        err(
-          "agent_trigger_incomplete",
-          `agents.${id}: trigger "${trigger.id}" (kind ${trigger.kind}) is not in the asset, so it must declare ${missing.join(", ")}`,
-          at
-        )
-      );
-    }
-  });
-  return out;
-}
-function checkConnectors(id, instance, facts, connectorIds) {
-  const out = [];
-  for (const [slot, connectorId] of Object.entries(instance.connectors ?? {})) {
-    const at = `agents.${id}.connectors.${slot}`;
-    if (!facts.connectorSlots.includes(slot)) {
-      const hint = facts.otherSlots.includes(slot) ? `"${slot}" is a slot of a non-connector item` : facts.connectorSlots.length > 0 ? `the asset's connector slots are: ${facts.connectorSlots.join(", ")}` : "the asset declares no connector slots";
-      out.push(
-        err(
-          "agent_connector_slot_unknown",
-          `agents.${id}: connectors.${slot} is not a connector slot id of the agent asset (${hint})`,
-          at
-        )
-      );
-    }
-    if (!connectorIds.includes(connectorId)) {
-      out.push(
-        err(
-          "agent_connector_unknown",
-          `agents.${id}: connectors.${slot} points at "${connectorId}", which is not in skaile.yaml connectors[]${connectorIds.length > 0 ? ` (has: ${connectorIds.join(", ")})` : ""}`,
-          at
-        )
-      );
-    }
-  }
-  return out;
-}
-function checkAgentInstances(projectDir, parsed) {
-  const diagnostics = [];
-  const instances = normalizeAgentInstances(parsed.agents, diagnostics);
-  const agent = isRecord(parsed.agent) ? parsed.agent : void 0;
-  diagnostics.push(...agentBlockKeyDiagnostics(parsed.agent));
-  if (agent?.subagents !== void 0) {
-    diagnostics.push(
-      err(
-        "agent_subagents_removed",
-        "`agent.subagents` was removed \u2014 declare each subagent as an agent asset and bind it under `agents:` with `lifecycle: role`",
-        "agent.subagents"
-      )
-    );
-  }
-  if (agent?.instances !== void 0) {
-    diagnostics.push(
-      err(
-        "misplaced_agent_instances",
-        "`agent.instances` is not a skaile.yaml key \u2014 declare instances under root `agents:`",
-        "agent.instances"
-      )
-    );
-  }
-  diagnostics.push(
-    ...agentInstanceDiagnostics({
-      agent: {
-        definition: typeof agent?.definition === "string" ? agent.definition : void 0,
-        instances
-      }
-    })
-  );
-  if (!instances) return diagnostics;
-  const connectorIds = (Array.isArray(parsed.connectors) ? parsed.connectors : []).flatMap(
-    (c) => isRecord(c) && typeof c.id === "string" ? [c.id] : []
-  );
-  for (const [id, instance] of Object.entries(instances)) {
-    const loaded = loadAsset(projectDir, id, instance.ref);
-    if ("diagnostic" in loaded) {
-      diagnostics.push(loaded.diagnostic, ...checkTriggers(id, instance.triggers ?? [], void 0));
-      continue;
-    }
-    const { facts } = loaded;
-    const lifecycle = instance.lifecycle ?? facts.lifecycle ?? "standing";
-    if (lifecycle === "role" && !facts.hasIo) {
-      diagnostics.push(
-        err(
-          "agent_role_missing_io",
-          `agents.${id}: lifecycle "role" needs the agent asset to declare \`io\` ({ input, output } JSON Schemas)`,
-          `agents.${id}.lifecycle`
-        )
-      );
-    }
-    diagnostics.push(...checkConnectors(id, instance, facts, connectorIds));
-    diagnostics.push(...checkTriggers(id, instance.triggers ?? [], facts.triggerIds));
-  }
-  return diagnostics;
-}
-
-// cli/src/commands/validate.ts
-var MANIFEST_GLOBS = [
-  { pattern: /\/SKILL\.md$/, kind: "skill" },
-  { pattern: /\/agent\.yaml$/, kind: "agent" },
-  { pattern: /\/AGENT\.md$/, kind: "agent" },
-  { pattern: /\/CONTRACT\.md$/, kind: "contract" },
-  { pattern: /\/PERSONA\.md$/, kind: "persona" },
-  { pattern: /\/RULESET\.md$/, kind: "ruleset" },
-  { pattern: /\.flow\.yaml$/, kind: "flow" },
-  { pattern: /\.flow\.json$/, kind: "flow" },
-  { pattern: /\/CONNECTOR\.md$/, kind: "connector" },
-  { pattern: /\.prompt\.md$/, kind: "prompt" },
-  { pattern: /\/MCP\.md$/, kind: "mcp-server" },
-  { pattern: /\/knowledge\.yaml$/, kind: "knowledge" },
-  { pattern: /\/knowledge\/index\.yaml$/, kind: "knowledge" },
-  { pattern: /\.preset\.yaml$/, kind: "preset" }
-];
 var HARNESS_DIRS = /* @__PURE__ */ new Set([".claude", ".codex", ".omp"]);
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -265,12 +33,12 @@ function findManifestCandidates(rootPath) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs2.readdirSync(dir, { withFileTypes: true });
+      entries = fs.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path2.join(dir, entry.name);
+      const fullPath = path.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name)) walk(fullPath);
       } else if (entry.isFile()) {
@@ -287,10 +55,12 @@ function findManifestCandidates(rootPath) {
   return candidates;
 }
 function parseManifestCandidate(c, absRoot) {
-  const content = fs2.readFileSync(c.filePath, "utf-8");
+  const content = fs.readFileSync(c.filePath, "utf-8");
   const res = parseManifestFile(c.filePath, content);
   if (!res.ok) {
-    logErr(`${path2.relative(absRoot, c.filePath)} [${c.kind}] \u2014 parse error: ${res.reason}`);
+    logErr(
+      `${path.relative(absRoot, c.filePath)} [${c.kind}] \u2014 ${manifestParseErrorText(res.reason)}`
+    );
     return { kind: "error" };
   }
   return {
@@ -300,25 +70,25 @@ function parseManifestCandidate(c, absRoot) {
   };
 }
 function libraryRootOf(absRoot) {
-  for (let dir = absRoot; ; dir = path2.dirname(dir)) {
-    if (fs2.existsSync(path2.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
-    if (path2.dirname(dir) === dir) return absRoot;
+  for (let dir = absRoot; ; dir = path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
+    if (path.dirname(dir) === dir) return absRoot;
   }
 }
 function validateManifestCandidate(c, parsed, body, absRoot, registry, strictConformance, composeRefs) {
-  const relPath = path2.relative(absRoot, c.filePath);
+  const relPath = path.relative(absRoot, c.filePath);
   let errors = 0;
   let warnings = 0;
-  const dirName = path2.basename(path2.dirname(c.filePath));
+  const dirName = path.basename(path.dirname(c.filePath));
   const checked = checkAsset(
     c.kind,
     parsed ?? {},
     body,
     dirName,
     registry,
-    fs2.readFileSync(c.filePath, "utf-8"),
-    path2.basename(c.filePath),
-    { dir: path2.dirname(c.filePath), libraryRoot: libraryRootOf(absRoot), composeRefs }
+    fs.readFileSync(c.filePath, "utf-8"),
+    path.basename(c.filePath),
+    { dir: path.dirname(c.filePath), libraryRoot: libraryRootOf(absRoot), composeRefs }
   );
   for (const f of checked.errors) {
     logErr(`${relPath} [${f.tag}] \u2014 ${f.text}`);
@@ -341,7 +111,7 @@ function scanIdentities(root) {
   for (const c of findManifestCandidates(root)) {
     let parsed;
     try {
-      const res = parseManifestFile(c.filePath, fs2.readFileSync(c.filePath, "utf-8"));
+      const res = parseManifestFile(c.filePath, fs.readFileSync(c.filePath, "utf-8"));
       if (!res.ok) continue;
       parsed = res.data;
     } catch {
@@ -355,14 +125,14 @@ function scanIdentities(root) {
   return identities;
 }
 function validateManifests(rootPath, strictConformance, registeredAssets = /* @__PURE__ */ new Set()) {
-  const absRoot = path2.resolve(rootPath);
-  if (!fs2.existsSync(absRoot)) {
+  const absRoot = path.resolve(rootPath);
+  if (!fs.existsSync(absRoot)) {
     logErr(`Path does not exist: ${absRoot}`);
     return { total: 0, errors: 1, warnings: 0 };
   }
   const registry = getKindRegistry();
   const candidates = findManifestCandidates(absRoot);
-  const isLibrary = fs2.existsSync(path2.join(absRoot, SKAILE_MANIFEST_FILENAME));
+  const isLibrary = fs.existsSync(path.join(absRoot, SKAILE_MANIFEST_FILENAME));
   let errors = reportLibrarySymlinks(absRoot, {
     wholeTree: isLibrary,
     skipDirs: isLibrary ? void 0 : HARNESS_DIRS
@@ -395,14 +165,14 @@ function validateManifests(rootPath, strictConformance, registeredAssets = /* @_
     const obj = parseResult.parsed;
     const identity = obj && typeof obj === "object" ? obj[c.kind === "flow" ? "id" : "name"] : null;
     if (typeof identity === "string" && identity.length > 0) {
-      const dir = path2.dirname(c.filePath);
+      const dir = path.dirname(c.filePath);
       const key = `${c.kind}:${identity}`;
       const first = seenIdentity.get(key);
       if (first === void 0) {
         seenIdentity.set(key, dir);
       } else if (first !== dir) {
         logErr(
-          `${path2.relative(absRoot, c.filePath)} [${c.kind}] \u2014 ${key} is also defined in ${path2.relative(absRoot, first) || "."}; two directories cannot share a kind and name (\`skaile library index\` keeps only the first).`
+          `${path.relative(absRoot, c.filePath)} [${c.kind}] \u2014 ${key} is also defined in ${path.relative(absRoot, first) || "."}; two directories cannot share a kind and name (\`skaile library index\` keeps only the first).`
         );
         errors++;
       }
@@ -415,12 +185,12 @@ function findWorkspaceManifests(rootPath) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs2.readdirSync(dir, { withFileTypes: true });
+      entries = fs.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path2.join(dir, entry.name);
+      const full = path.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name)) walk(full);
       } else if (entry.isFile() && /(^|\.)skaile\.yaml$/.test(entry.name)) {
@@ -500,7 +270,7 @@ function validateLocalConnectorMountPaths(projectDir, relPath, connectors) {
     const dir = localConnectorMountDir(c, projectDir);
     if (!dir) continue;
     const escapesTo = symlinkEscapeOfProject(dir, projectDir);
-    if (!fs2.existsSync(dir)) {
+    if (!fs.existsSync(dir)) {
       logErr(
         `${relPath} [connectors] \u2014 connector_mount_path_missing: connectors.${c.id}.mountPath: ${dir} does not exist; create the directory or fix the path`
       );
@@ -519,14 +289,14 @@ function validateLocalConnectorMountPaths(projectDir, relPath, connectors) {
   return errors;
 }
 async function validateWorkspaceManifests(rootPath) {
-  const absRoot = path2.resolve(rootPath);
+  const absRoot = path.resolve(rootPath);
   const files = findWorkspaceManifests(absRoot);
   let errors = 0;
   for (const file of files) {
-    const relPath = path2.relative(absRoot, file);
+    const relPath = path.relative(absRoot, file);
     let parsed;
     try {
-      parsed = parse(fs2.readFileSync(file, "utf-8")) ?? {};
+      parsed = parse(fs.readFileSync(file, "utf-8")) ?? {};
     } catch (e) {
       logErr(`${relPath} \u2014 parse error: ${e instanceof Error ? e.message : String(e)}`);
       errors++;
@@ -534,7 +304,7 @@ async function validateWorkspaceManifests(rootPath) {
     }
     errors += validateWorkspaceRefs(collectWorkspaceRefFields(parsed), relPath);
     errors += validateWorkspaceAssets(parsed, relPath);
-    for (const d of checkAgentInstances(path2.dirname(file), parsed)) {
+    for (const d of checkAgentInstances(path.dirname(file), parsed)) {
       const line = `${relPath} [agents] \u2014 ${d.code}: ${d.path ? `${d.path}: ` : ""}${d.message}`;
       if (d.severity === "error") {
         logErr(line);
@@ -543,7 +313,7 @@ async function validateWorkspaceManifests(rootPath) {
         logWarn(line);
       }
     }
-    const decoded = decodeSkaileYaml(fs2.readFileSync(file, "utf-8"));
+    const decoded = decodeSkaileYaml(fs.readFileSync(file, "utf-8"));
     for (const d of decoded.diagnostics) {
       if (!CONNECTOR_ERROR_CODES.includes(d.code)) continue;
       logErr(`${relPath} [connectors] \u2014 ${d.code}: ${d.path ? `${d.path}: ` : ""}${d.message}`);
@@ -554,13 +324,28 @@ async function validateWorkspaceManifests(rootPath) {
       logErr(relPath === "skaile.yaml" ? d.message : `${relPath} \u2014 ${d.message}`);
       errors++;
     }
+    for (const d of decoded.diagnostics) {
+      if (d.code !== "deprecated_harness_key" && d.code !== "harness_key_conflict") continue;
+      const line = `${relPath} [agent-config] \u2014 ${d.code}: ${d.message}`;
+      if (d.severity === "error") {
+        logErr(line);
+        errors++;
+      } else {
+        logWarn(line);
+      }
+    }
+    for (const line of unknownKeyWarnings(decoded.diagnostics, relPath)) logWarn(line);
+    for (const line of await unknownHarnessErrors(path.dirname(file), decoded.config, relPath)) {
+      logErr(line);
+      errors++;
+    }
     errors += validateLocalConnectorMountPaths(
-      path2.dirname(file),
+      path.dirname(file),
       relPath,
       decoded.config?.connectors ?? []
     );
     if ((decoded.config?.connectors ?? []).length > 0) {
-      const assets = await resolveRuntimeAssets(path2.dirname(file));
+      const assets = await resolveRuntimeAssets(path.dirname(file));
       if (!assets.warnings.some((w) => w.code === "repo_unavailable")) {
         for (const w of assets.warnings) {
           if (w.code !== "missing_driver" || !w.name) continue;
@@ -573,7 +358,7 @@ async function validateWorkspaceManifests(rootPath) {
   return { total: files.length, errors };
 }
 function validatePublishManifestRoots(rootPath) {
-  const absRoot = path2.resolve(rootPath);
+  const absRoot = path.resolve(rootPath);
   const manifest = loadSkPublishManifest(absRoot);
   if (!manifest) return 0;
   const missing = missingRootAssets(absRoot, manifest);
@@ -582,40 +367,37 @@ function validatePublishManifestRoots(rootPath) {
       `${SKAILE_MANIFEST_FILENAME} [assets] \u2014 ${assetEntryRef(a, manifest)}: root "${a.root}" does not exist. Run \`skaile library index <library>\` to drop the entry, or restore the directory.`
     );
   }
-  let unmatchedEntries = 0;
-  if (!manifest.source) {
-    for (const a of manifest.assets ?? []) {
-      if (a.root || a.source || !Array.isArray(a.files) || a.files.length === 0) continue;
-      const patterns = a.files.map((f) => typeof f === "string" ? f : f.path).filter(Boolean);
-      const { unmatched } = expandManifestFiles(absRoot, patterns);
-      if (unmatched.length === 0) continue;
-      unmatchedEntries++;
-      logErr(
-        `${SKAILE_MANIFEST_FILENAME} [assets] \u2014 ${assetEntryRef(a, manifest)}: files: ${unmatched.join(", ")} not found. Fix the \`files:\` list or drop the entry.`
-      );
-    }
-  }
-  return missing.length + unmatchedEntries;
+  return missing.length;
 }
 async function validatePublishManifestUnlisted(rootPath) {
-  const absRoot = path2.resolve(rootPath);
+  const absRoot = path.resolve(rootPath);
   const manifest = loadSkPublishManifest(absRoot);
   if (!manifest) return 0;
+  const registry = getKindRegistry();
+  const libraryRoot = libraryRootOf(absRoot);
+  const composeRefs = composeRefContext(
+    scanIdentities(libraryRoot),
+    await registeredAssetKeys(libraryRoot),
+    manifest.publisher
+  );
   const unlisted = (await scanUnlistedAssets(
     absRoot,
-    manifest.publisher ?? path2.basename(absRoot),
-    getKindRegistry(),
+    manifest.publisher ?? path.basename(absRoot),
+    registry,
     UNLISTED_SCAN_SKIP_DIRS
-  )).filter((u) => !u.registeredAt && !u.parseFailure);
+  )).filter(
+    (u) => !u.registeredAt && !u.parseFailure && // a file that does not parse has its own parse error
+    checkAssetFile(u.entry.source, u.entry.kind, registry, absRoot, composeRefs).length === 0
+  );
   for (const u of unlisted) {
     logErr(
-      `${path2.relative(absRoot, u.entry.source)} [${u.entry.kind}] \u2014 ${u.entry.kind}:${u.entry.name} is on disk but not in ${SKAILE_MANIFEST_FILENAME}, so it is not published. Run \`skaile library index <library>\` to list it, or delete the directory.`
+      `${path.relative(absRoot, u.entry.source)} [${u.entry.kind}] \u2014 ${u.entry.kind}:${u.entry.name} is on disk but not in ${SKAILE_MANIFEST_FILENAME}, so it is not published. Run \`skaile library index <library>\` to list it, or delete the directory.`
     );
   }
   return unlisted.length;
 }
 function validatePublishManifestRequires(rootPath) {
-  const problems = manifestRequiresProblems(path2.resolve(rootPath));
+  const problems = manifestRequiresProblems(path.resolve(rootPath));
   for (const p of problems) {
     logErr(
       `${SKAILE_MANIFEST_FILENAME} [assets] \u2014 ${p.asset}: ${p.message}. Use the \`kind:@<publisher>/name[#version]\` form.`
@@ -624,29 +406,30 @@ function validatePublishManifestRequires(rootPath) {
   return problems.length;
 }
 function validatePublishManifestPublisherSlugs(rootPath) {
-  const problems = manifestPublisherProblems(path2.resolve(rootPath));
+  const problems = manifestPublisherProblems(path.resolve(rootPath));
   for (const message of problems) logErr(message);
   return problems.length;
 }
 function validatePublishManifestRootPaths(rootPath) {
   const problems = [
-    ...manifestRootProblems(path2.resolve(rootPath)),
-    ...manifestEntryNameProblems(path2.resolve(rootPath))
+    ...manifestRootProblems(path.resolve(rootPath)),
+    ...manifestFilesProblems(path.resolve(rootPath)),
+    ...manifestEntryNameProblems(path.resolve(rootPath))
   ];
   for (const message of problems) logErr(message);
   return problems.length;
 }
 function validatePublishManifestParses(rootPath) {
   try {
-    assertManifestEditable(path2.resolve(rootPath));
+    assertManifestEditable(path.resolve(rootPath));
     return 0;
-  } catch (err2) {
-    logErr(err2 instanceof Error ? err2.message : String(err2));
+  } catch (err) {
+    logErr(err instanceof Error ? err.message : String(err));
     return 1;
   }
 }
 function validatePublishManifestVersions(rootPath) {
-  const absRoot = path2.resolve(rootPath);
+  const absRoot = path.resolve(rootPath);
   const manifest = loadSkPublishManifest(absRoot);
   if (!manifest || manifest.source) return 0;
   let warnings = 0;
@@ -654,7 +437,7 @@ function validatePublishManifestVersions(rootPath) {
     if (a.source || !a.version) continue;
     const file = findEntryManifestFile(absRoot, a);
     if (!file) continue;
-    const res = parseManifestFile(file, fs2.readFileSync(file, "utf-8"));
+    const res = parseManifestFile(file, fs.readFileSync(file, "utf-8"));
     if (!res.ok) continue;
     const fileVersion = declaredVersion(res.data);
     if (fileVersion === void 0 || fileVersion === a.version) continue;
@@ -662,7 +445,7 @@ function validatePublishManifestVersions(rootPath) {
       manifestVersionMismatchMessage(
         assetEntryRef(a, manifest),
         a.version,
-        toPosix(path2.relative(absRoot, file)),
+        toPosix(path.relative(absRoot, file)),
         fileVersion
       )
     );
@@ -671,7 +454,7 @@ function validatePublishManifestVersions(rootPath) {
   return warnings;
 }
 function validatePublishManifestPublishers(rootPath) {
-  const absRoot = path2.resolve(rootPath);
+  const absRoot = path.resolve(rootPath);
   const manifest = loadSkPublishManifest(absRoot);
   if (!manifest || manifest.source) return 0;
   const bare = (p) => p.trim().replace(/^@/, "");
@@ -681,13 +464,13 @@ function validatePublishManifestPublishers(rootPath) {
     if (a.source || !resolved) continue;
     const file = findEntryManifestFile(absRoot, a);
     if (!file) continue;
-    const res = parseManifestFile(file, fs2.readFileSync(file, "utf-8"));
+    const res = parseManifestFile(file, fs.readFileSync(file, "utf-8"));
     if (!res.ok) continue;
     const meta = res.data.metadata;
     const declared = meta !== null && typeof meta === "object" ? meta.publisher : null;
     if (typeof declared !== "string" || bare(declared) === bare(resolved)) continue;
     logWarn(
-      `${toPosix(path2.relative(absRoot, file))} [publisher] \u2014 metadata.publisher "${bare(declared)}" differs from the manifest publisher "${bare(resolved)}" for ${assetEntryRef(a, manifest)}. The manifest wins and the file value is ignored: delete \`metadata.publisher\` from the file, or set the publisher in ${SKAILE_MANIFEST_FILENAME}.`
+      `${toPosix(path.relative(absRoot, file))} [publisher] \u2014 metadata.publisher "${bare(declared)}" differs from the manifest publisher "${bare(resolved)}" for ${assetEntryRef(a, manifest)}. The manifest wins and the file value is ignored: delete \`metadata.publisher\` from the file, or set the publisher in ${SKAILE_MANIFEST_FILENAME}.`
     );
     warnings++;
   }
@@ -695,7 +478,7 @@ function validatePublishManifestPublishers(rootPath) {
 }
 var EXCLUDED_PATHS = ["skaileup-shared/", "external/", "docs/"];
 function toPosix(p) {
-  return p.split(path2.sep).join("/");
+  return p.split(path.sep).join("/");
 }
 function isExcludedPath(relPath) {
   const rel = toPosix(relPath);
@@ -711,9 +494,9 @@ var VERSIONED_KINDS = {
 };
 function readAssetVersion(c) {
   const kind = c.kind;
-  const fileName = path2.basename(c.filePath);
-  const dirName = path2.basename(path2.dirname(c.filePath));
-  const content = fs2.readFileSync(c.filePath, "utf-8");
+  const fileName = path.basename(c.filePath);
+  const dirName = path.basename(path.dirname(c.filePath));
+  const content = fs.readFileSync(c.filePath, "utf-8");
   if (c.filePath.endsWith(".md")) {
     const res = parseManifestFile(c.filePath, content);
     const data = res.ok ? res.data : {};
@@ -746,26 +529,26 @@ function readAssetVersion(c) {
   };
 }
 function collectAssetVersions(root) {
-  if (!fs2.existsSync(root)) return [];
+  if (!fs.existsSync(root)) return [];
   const assets = [];
   for (const c of findManifestCandidates(root)) {
     if (!VERSIONED_KINDS[c.kind]) continue;
     if (c.filePath.endsWith(".flow.json")) continue;
-    if (isExcludedPath(path2.relative(root, c.filePath))) continue;
+    if (isExcludedPath(path.relative(root, c.filePath))) continue;
     assets.push(readAssetVersion(c));
   }
   return assets;
 }
 function assetLocation(a, root) {
-  return toPosix(path2.relative(root, a.filePath));
+  return toPosix(path.relative(root, a.filePath));
 }
 function findChangelogUnit(assetRelPath, root) {
-  let dir = path2.posix.dirname(toPosix(assetRelPath));
+  let dir = path.posix.dirname(toPosix(assetRelPath));
   for (; ; ) {
     const candidate = dir === "." ? "CHANGELOG.md" : `${dir}/CHANGELOG.md`;
-    if (fs2.existsSync(path2.join(root, candidate))) return candidate;
+    if (fs.existsSync(path.join(root, candidate))) return candidate;
     if (dir === ".") return null;
-    dir = path2.posix.dirname(dir);
+    dir = path.posix.dirname(dir);
   }
 }
 function checkChangelogUnits(modifiedFiles, root) {
@@ -815,7 +598,7 @@ function checkVersionBumps(assets, root) {
   let warnings = 0;
   for (const a of assets) {
     if (!a.version) continue;
-    const relPath = toPosix(path2.relative(root, a.filePath));
+    const relPath = toPosix(path.relative(root, a.filePath));
     try {
       const headContent = execFileSync("git", ["show", `HEAD:./${relPath}`], {
         cwd: root,
@@ -846,9 +629,9 @@ function checkFlowVersionPins(assets, root) {
     let pins;
     try {
       pins = flowSkillVersionPins(loadFlow(f.filePath));
-    } catch (err2) {
+    } catch (err) {
       logWarn(
-        `flow:${f.name} (${path2.relative(root, f.filePath)}) \u2014 could not be read: ${err2 instanceof Error ? err2.message : err2}`
+        `flow:${f.name} (${path.relative(root, f.filePath)}) \u2014 could not be read: ${err instanceof Error ? err.message : err}`
       );
       warnings++;
       continue;
@@ -866,16 +649,16 @@ function checkFlowVersionPins(assets, root) {
 }
 function resolveCheckRoot(pathArg) {
   if (pathArg) {
-    const abs = path2.resolve(pathArg);
-    if (!fs2.existsSync(abs)) {
+    const abs = path.resolve(pathArg);
+    if (!fs.existsSync(abs)) {
       logErr(`Path does not exist: ${abs}`);
       return null;
     }
     return abs;
   }
-  for (let dir = process.cwd(); ; dir = path2.dirname(dir)) {
-    if (fs2.existsSync(path2.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
-    if (path2.dirname(dir) === dir) return AI_RESOURCES;
+  for (let dir = process.cwd(); ; dir = path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
+    if (path.dirname(dir) === dir) return AI_RESOURCES;
   }
 }
 function isInGitWorkTree(root) {
@@ -889,11 +672,28 @@ function isInGitWorkTree(root) {
     return false;
   }
 }
+function hasCommit(root) {
+  try {
+    execFileSync("git", ["rev-parse", "--verify", "--quiet", "HEAD"], {
+      cwd: root,
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function changedFiles(root, ref, what, opts = {}) {
   if (!isInGitWorkTree(root)) {
     logErr(`${what} needs a git repository: ${root} is not inside a git work tree.`);
     return null;
   }
+  if (ref === "HEAD" && !hasCommit(root)) {
+    logErr(
+      `${what} compares with the last commit, and ${root} has no commit yet. Commit the library first (\`skaile library commit <name>\`), then run it again.`
+    );
+    return null;
+  }
   try {
     const out = execFileSync(
       "git",
@@ -914,16 +714,16 @@ function changedFiles(root, ref, what, opts = {}) {
       changed.push(...fresh.trim().split("\n").filter(Boolean));
     }
     return changed;
-  } catch (err2) {
-    const stderr = err2 instanceof Error && "stderr" in err2 ? String(err2.stderr).trim() : "";
-    const reason = (stderr || (err2 instanceof Error ? err2.message : String(err2))).split("\n")[0];
+  } catch (err) {
+    const stderr = err instanceof Error && "stderr" in err ? String(err.stderr).trim() : "";
+    const reason = (stderr || (err instanceof Error ? err.message : String(err))).split("\n")[0];
     logErr(`git diff failed in ${root}: ${reason}`);
     return null;
   }
 }
 function assetOwnDir(a) {
-  const dir = path2.dirname(a.filePath);
-  if (["skill", "agent", "contract"].includes(a.kind) || path2.basename(dir) === a.name) return dir;
+  const dir = path.dirname(a.filePath);
+  if (["skill", "agent", "contract"].includes(a.kind) || path.basename(dir) === a.name) return dir;
   return null;
 }
 function assetChanged(a, changedAbs) {
@@ -931,8 +731,8 @@ function assetChanged(a, changedAbs) {
   const dir = assetOwnDir(a);
   if (dir === null) return false;
   for (const f of changedAbs) {
-    const rel = path2.relative(dir, f);
-    if (rel.startsWith("..") || path2.isAbsolute(rel)) continue;
+    const rel = path.relative(dir, f);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) continue;
     if (!isNonAssetPath(toPosix(rel))) return true;
   }
   return false;
@@ -957,7 +757,7 @@ function runVersionsCheck(pathArg, opts) {
       process.exit(1);
       return;
     }
-    const changedAbs = new Set(changed.map((f) => path2.resolve(root, f)));
+    const changedAbs = new Set(changed.map((f) => path.resolve(root, f)));
     assets = assets.filter((a) => assetChanged(a, changedAbs));
   }
   logInfo(`Checking versions in ${root}`);
@@ -990,8 +790,8 @@ function makeValidateCommand() {
     "--strict-conformance",
     "Treat Agent Skills (agentskills.io) standard findings as errors"
   ).action(async (targetPath, opts) => {
-    const absPath = path2.resolve(targetPath);
-    if (fs2.existsSync(absPath) && !fs2.statSync(absPath).isDirectory()) {
+    const absPath = path.resolve(targetPath);
+    if (fs.existsSync(absPath) && !fs.statSync(absPath).isDirectory()) {
       logErr(`${absPath} is not a directory: nothing to validate. Pass the library directory.`);
       process.exit(1);
       return;
@@ -1019,7 +819,7 @@ function makeValidateCommand() {
     warnIgnoredDomainFiles(absPath);
     warnLegacyBundleFiles(absPath);
     logInfo(`Scanned ${total} asset manifest(s) and ${ws.total} skaile.yaml file(s)`);
-    if (total === 0 && ws.total === 0 && totalErrors === 0 && !fs2.existsSync(path2.join(absPath, SKAILE_MANIFEST_FILENAME))) {
+    if (total === 0 && ws.total === 0 && totalErrors === 0 && !fs.existsSync(path.join(absPath, SKAILE_MANIFEST_FILENAME))) {
       logErr(
         `Nothing to validate in ${absPath}: no asset manifest, skaile.yaml or ${SKAILE_MANIFEST_FILENAME} found.`
       );
@@ -1067,6 +867,6 @@ function makeValidateCommand() {
   return cmd;
 }
 
-export { isRecord, makeValidateCommand, scanIdentities };
-//# sourceMappingURL=chunk-ZQSOJH6I.js.map
-//# sourceMappingURL=chunk-ZQSOJH6I.js.map
+export { makeValidateCommand, scanIdentities };
+//# sourceMappingURL=chunk-IHFGPHCT.js.map
+//# sourceMappingURL=chunk-IHFGPHCT.js.map