@skaile/workspaces 0.29.0 → 0.30.1

package/dist/{chunk-JIQLLZ65.js → chunk-7MANNJ3U.js}

@@ -1,13 +1,13 @@
-import { AssetKindRegistryFrozenError, AssetKindConflictError, AssetKindPatternConflictError, AssetKindPathAmbiguityError } from './chunk-OKRUTSG7.js';
-import { decodeSkaileManifest, SKAILE_MANIFEST_FILENAME } from './chunk-IERB3UXJ.js';
-import { parseFrontmatter } from './chunk-2FS4FPZ7.js';
-import { isValidAssetName } from './chunk-IEJ5IOC3.js';
-import { validatePersona, validateRuleset, validateSkill, validateAgent, validateConnector, validateMcpServer, validateContract, validatePrompt, validatePreset } from './chunk-QDJKE557.js';
+import { AssetKindRegistryFrozenError, AssetKindConflictError, AssetKindPatternConflictError, AssetKindPathAmbiguityError } from './chunk-ZDKJHQY2.js';
+import { decodeSkaileManifest, SKAILE_MANIFEST_FILENAME } from './chunk-H5YXL4KI.js';
+import { parseFrontmatter } from './chunk-4AGIEU7V.js';
+import { isValidAssetName } from './chunk-LFDZYCEO.js';
+import { validatePersona, validateRuleset, validateSkill, validateAgent, validateConnector, validateMcpServer, validateContract, validatePrompt, validatePreset } from './chunk-HRKB2ATT.js';
 import * as fs from 'fs';
 import * as path from 'path';
-import * as z from 'zod';
 import * as yaml from 'js-yaml';
 import * as crypto from 'crypto';
+import * as z from 'zod';
 
 // discovery/src/asset-kind-registry.ts
 var AssetKindRegistry = class {
@@ -466,6 +466,44 @@ var BUILTIN_PROVIDERS = [
   // Composition entity (discoverable, not in AssetKind enum)
   presetProvider
 ];
+function computeDeterministicHash(assetRoot, files) {
+  const hash = crypto.createHash("sha256");
+  const sorted = [...files].sort();
+  for (const file of sorted) {
+    const fullPath = path.join(assetRoot, file);
+    try {
+      hash.update(file);
+      hash.update("\0");
+      const content = fs.readFileSync(fullPath);
+      hash.update(content);
+      hash.update("\0");
+    } catch {
+    }
+  }
+  return hash.digest("hex");
+}
+function computeDeterministicHashDetailed(assetRoot, files) {
+  const hash = crypto.createHash("sha256");
+  const sorted = [...files].sort();
+  const present = [];
+  const missing = [];
+  for (const file of sorted) {
+    const fullPath = path.join(assetRoot, file);
+    let content = null;
+    try {
+      content = fs.readFileSync(fullPath);
+    } catch {
+      missing.push(file);
+      continue;
+    }
+    hash.update(file);
+    hash.update("\0");
+    hash.update(content);
+    hash.update("\0");
+    present.push(file);
+  }
+  return { sha256: hash.digest("hex"), present, missing };
+}
 var SEMVER_RE = /^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?(?:\+[a-zA-Z0-9.-]+)?$/;
 var PublisherOverrideSchema = z.object({
   /** Relative path within the repo (trailing slash convention). */
@@ -755,44 +793,8 @@ function loadSourceConfigFromDir(dir) {
     };
   }
 }
-function computeDeterministicHash(assetRoot, files) {
-  const hash = crypto.createHash("sha256");
-  const sorted = [...files].sort();
-  for (const file of sorted) {
-    const fullPath = path.join(assetRoot, file);
-    try {
-      hash.update(file);
-      hash.update("\0");
-      const content = fs.readFileSync(fullPath);
-      hash.update(content);
-      hash.update("\0");
-    } catch {
-    }
-  }
-  return hash.digest("hex");
-}
-function computeDeterministicHashDetailed(assetRoot, files) {
-  const hash = crypto.createHash("sha256");
-  const sorted = [...files].sort();
-  const present = [];
-  const missing = [];
-  for (const file of sorted) {
-    const fullPath = path.join(assetRoot, file);
-    let content = null;
-    try {
-      content = fs.readFileSync(fullPath);
-    } catch {
-      missing.push(file);
-      continue;
-    }
-    hash.update(file);
-    hash.update("\0");
-    hash.update(content);
-    hash.update("\0");
-    present.push(file);
-  }
-  return { sha256: hash.digest("hex"), present, missing };
-}
+
+// discovery/src/discover-manifest.ts
 function discoverFromManifest(rootPath, sourceConfig, registry, includeDev = false) {
   const assets = [];
   const errors = [];
@@ -995,6 +997,179 @@ function validateRequiresSyntax(requires) {
   return errors;
 }
 
+// discovery/src/domains.ts
+var DOMAIN_RELATIONS = /* @__PURE__ */ new Set([
+  "additions",
+  "alternatives",
+  "sequence"
+]);
+var DOMAIN_SLUG_RE = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+var DOMAIN_SLUG_MAX = 39;
+var DOMAIN_MD_FILENAME = "DOMAIN.md";
+function isDomainMdPath(relativePath) {
+  return relativePath === DOMAIN_MD_FILENAME || relativePath.endsWith(`/${DOMAIN_MD_FILENAME}`);
+}
+function posixDirname(p) {
+  const i = p.lastIndexOf("/");
+  return i === -1 ? "" : p.slice(0, i);
+}
+function normalizeMembers(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const m of raw) {
+    if (typeof m === "string" && m.length > 0) {
+      out.push({ ref: m });
+    } else if (m && typeof m === "object" && typeof m.ref === "string") {
+      const obj = m;
+      const member = { ref: obj.ref };
+      if (typeof obj.order === "number") member.order = obj.order;
+      if (obj.recommended === true) member.recommended = true;
+      out.push(member);
+    }
+  }
+  return out.length > 0 ? out : void 0;
+}
+function parseDomainMd(domainMdPath, frontmatter) {
+  const slug = typeof frontmatter.slug === "string" ? frontmatter.slug : "";
+  const title = typeof frontmatter.title === "string" && frontmatter.title.length > 0 ? frontmatter.title : slug;
+  const description = typeof frontmatter.description === "string" ? frontmatter.description.trim() : "";
+  const relation = typeof frontmatter.relation === "string" ? frontmatter.relation : "additions";
+  const order = typeof frontmatter.order === "number" ? frontmatter.order : void 0;
+  const members = normalizeMembers(frontmatter.members);
+  return {
+    domainRoot: posixDirname(domainMdPath),
+    slug,
+    title,
+    description,
+    relation,
+    ...order !== void 0 ? { order } : {},
+    ...members ? { members } : {}
+  };
+}
+function claims(root, target) {
+  if (root === "") return true;
+  return target === root || target.startsWith(`${root}/`);
+}
+function validateDomains(domains) {
+  const errors = [];
+  for (const d of domains) {
+    if (!d.slug || !DOMAIN_SLUG_RE.test(d.slug) || d.slug.length > DOMAIN_SLUG_MAX) {
+      errors.push({ code: "InvalidSlug", root: d.domainRoot, value: d.slug });
+    }
+    if (!DOMAIN_RELATIONS.has(d.relation)) {
+      errors.push({ code: "InvalidRelation", root: d.domainRoot, value: d.relation });
+    }
+  }
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const d of domains) {
+    if (!d.slug) continue;
+    const roots2 = bySlug.get(d.slug) ?? [];
+    roots2.push(d.domainRoot);
+    bySlug.set(d.slug, roots2);
+  }
+  for (const [slug, roots2] of bySlug) {
+    if (roots2.length > 1) errors.push({ code: "DuplicateDomainSlug", slug, roots: roots2.sort() });
+  }
+  const roots = domains.map((d) => d.domainRoot).sort();
+  for (let i = 0; i < roots.length; i++) {
+    for (let j = i + 1; j < roots.length; j++) {
+      const a = roots[i];
+      const b = roots[j];
+      if (a === b) continue;
+      if (claims(a, b)) errors.push({ code: "DomainNesting", outer: a, inner: b });
+      else if (claims(b, a)) errors.push({ code: "DomainNesting", outer: b, inner: a });
+    }
+  }
+  return errors;
+}
+function assignDomain(relativePath, domains) {
+  let best;
+  for (const d of domains) {
+    if (!d.slug) continue;
+    if (!claims(d.domainRoot, relativePath)) continue;
+    if (!best || d.domainRoot.length > best.domainRoot.length) best = d;
+  }
+  return best ? best.slug : null;
+}
+function buildDomainIndex(assets, domains) {
+  const index = {};
+  const unclaimed = [];
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const d of domains) bySlug.set(d.slug, d);
+  const refsBySlug = /* @__PURE__ */ new Map();
+  for (const asset of assets) {
+    const slug = assignDomain(asset.relativePath, domains);
+    if (slug === null) {
+      unclaimed.push(asset.ref);
+      continue;
+    }
+    const list = refsBySlug.get(slug) ?? [];
+    list.push(asset.ref);
+    refsBySlug.set(slug, list);
+  }
+  for (const [slug, refs] of refsBySlug) {
+    const d = bySlug.get(slug);
+    const memberOrder = /* @__PURE__ */ new Map();
+    const recommended = /* @__PURE__ */ new Set();
+    for (const m of d.members ?? []) {
+      if (m.order !== void 0) memberOrder.set(m.ref, m.order);
+      if (m.recommended) recommended.add(m.ref);
+    }
+    const ordered = refs.map((ref, i) => ({ ref, i, order: memberOrder.get(ref) })).sort((a, b) => {
+      if (a.order !== void 0 && b.order !== void 0) return a.order - b.order || a.i - b.i;
+      if (a.order !== void 0) return -1;
+      if (b.order !== void 0) return 1;
+      return a.i - b.i;
+    }).map((x) => x.ref);
+    index[slug] = {
+      slug,
+      title: d.title,
+      description: d.description,
+      relation: d.relation,
+      ...d.order !== void 0 ? { order: d.order } : {},
+      members: ordered,
+      recommended: ordered.filter((ref) => recommended.has(ref))
+    };
+  }
+  return { index, unclaimed };
+}
+function describeDomainError(e) {
+  switch (e.code) {
+    case "DomainNesting":
+      return {
+        path: `${e.inner}/${DOMAIN_MD_FILENAME}`,
+        error: `DomainNesting: domain at '${e.inner}' is nested inside domain at '${e.outer || "<repo root>"}'`
+      };
+    case "DuplicateDomainSlug":
+      return {
+        path: `${e.roots[0] ?? ""}/${DOMAIN_MD_FILENAME}`,
+        error: `DuplicateDomainSlug: slug '${e.slug}' declared by ${e.roots.join(", ")}`
+      };
+    case "InvalidRelation":
+      return {
+        path: `${e.root}/${DOMAIN_MD_FILENAME}`,
+        error: `InvalidRelation: '${e.value}' (expected additions|alternatives|sequence)`
+      };
+    case "InvalidSlug":
+      return {
+        path: `${e.root}/${DOMAIN_MD_FILENAME}`,
+        error: `InvalidSlug: '${e.value}' (expected lowercase a-z0-9 with single hyphens, \u226439 chars)`
+      };
+  }
+}
+function applyDomains(assets, domains) {
+  const errors = validateDomains(domains).map(describeDomainError);
+  for (const a of assets) {
+    const slug = assignDomain(a.relativePath, domains);
+    if (slug) a.domainSlug = slug;
+  }
+  const { index } = buildDomainIndex(assets, domains);
+  const ordered = Object.values(index).sort(
+    (a, b) => (a.order ?? Number.POSITIVE_INFINITY) - (b.order ?? Number.POSITIVE_INFINITY) || (a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0)
+  );
+  return { domains: ordered, errors };
+}
+
 // discovery/src/discover.ts
 function createDefaultRegistry() {
   const registry = new AssetKindRegistry();
@@ -1004,29 +1179,16 @@ function createDefaultRegistry() {
   return registry;
 }
 function discoverAssetsInTree(rootPath, optionsOrSourceConfig) {
-  let sourceConfig;
-  let registry;
-  let sidecarPath;
-  let includeDev = false;
-  if (optionsOrSourceConfig && ("registry" in optionsOrSourceConfig || "sourceConfig" in optionsOrSourceConfig || "sidecarPath" in optionsOrSourceConfig || "includeDev" in optionsOrSourceConfig)) {
-    sourceConfig = optionsOrSourceConfig.sourceConfig;
-    registry = optionsOrSourceConfig.registry;
-    sidecarPath = optionsOrSourceConfig.sidecarPath;
-    includeDev = optionsOrSourceConfig.includeDev ?? false;
-  } else {
-    sourceConfig = optionsOrSourceConfig;
-  }
-  if (!registry) {
-    registry = createDefaultRegistry();
-  }
-  if (!sourceConfig && sidecarPath) {
-    const merged = loadMergedSourceConfig(rootPath, sidecarPath);
-    if (merged.ok) {
-      sourceConfig = merged.config;
-    }
-  }
+  const { sourceConfig, registry, includeDev, sidecarPath, domainFiles } = normalizeDiscoveryArgs(
+    rootPath,
+    optionsOrSourceConfig
+  );
+  const domainMds = domainFiles ? domainFiles.map((f) => parseDomainMd(f.path, parseDomainFrontmatter(f.content))) : collectDomainMds(sidecarPath ?? rootPath);
   if (sourceConfig && isManifestMode(sourceConfig)) {
-    return discoverFromManifest(rootPath, sourceConfig, registry, includeDev);
+    return finalizeDomains(
+      discoverFromManifest(rootPath, sourceConfig, registry, includeDev),
+      domainMds
+    );
   }
   const assets = [];
   const errors = [];
@@ -1050,45 +1212,104 @@ function discoverAssetsInTree(rootPath, optionsOrSourceConfig) {
     const dedupKey = `${dir}:${kind}`;
     if (seen.has(dedupKey)) continue;
     seen.add(dedupKey);
+    processDiscoveredEntry(
+      { absPath, relativePath, kind },
+      { registry, sourceConfig },
+      { assets, errors, allEdges }
+    );
+  }
+  const graph = buildRequiresGraph(allEdges);
+  return finalizeDomains({ assets, graph, errors }, domainMds);
+}
+function parseDomainFrontmatter(content) {
+  const { data } = parseFrontmatter(content);
+  return data && typeof data === "object" ? data : {};
+}
+function collectDomainMds(dir) {
+  const out = [];
+  for (const { absPath, relativePath } of walkTree(dir)) {
+    if (!isDomainMdPath(relativePath)) continue;
     try {
-      const manifest = parseManifest2(absPath);
-      if (!manifest) {
-        errors.push({ path: relativePath, error: "Failed to parse manifest" });
-        continue;
-      }
-      const publisher = resolvePublisher(relativePath, sourceConfig);
-      const name = deriveName(relativePath, kind, manifest);
-      const version = coerceVersion(manifest.version);
-      const ref = `${publisher}/${name}@${version}`;
-      const fileFilter = registry.defaultFileFilter(kind, absPath) ?? {
-        assetRoot: path.dirname(absPath),
-        files: [path.basename(absPath)]
-      };
-      const sha256 = computeDeterministicHash(fileFilter.assetRoot, fileFilter.files);
-      const requires = registry.extractRequires(kind, ref, manifest);
-      allEdges.push(...requires);
-      assets.push({
-        ref,
-        kind,
-        publisher,
-        name,
-        version,
-        manifest,
-        manifestPath: absPath,
-        relativePath,
-        fileFilter,
-        sha256,
-        requires
-      });
-    } catch (err) {
-      errors.push({
-        path: relativePath,
-        error: err instanceof Error ? err.message : String(err)
-      });
+      out.push(
+        parseDomainMd(relativePath, parseDomainFrontmatter(fs.readFileSync(absPath, "utf-8")))
+      );
+    } catch {
     }
   }
-  const graph = buildRequiresGraph(allEdges);
-  return { assets, graph, errors };
+  return out;
+}
+function finalizeDomains(result, domainMds) {
+  if (domainMds.length === 0) return result;
+  const { domains, errors } = applyDomains(result.assets, domainMds);
+  result.errors.push(...errors);
+  if (domains.length > 0) result.domains = domains;
+  return result;
+}
+function normalizeDiscoveryArgs(rootPath, optionsOrSourceConfig) {
+  let sourceConfig;
+  let registry;
+  let sidecarPath;
+  let includeDev = false;
+  let domainFiles;
+  if (optionsOrSourceConfig && ("registry" in optionsOrSourceConfig || "sourceConfig" in optionsOrSourceConfig || "sidecarPath" in optionsOrSourceConfig || "domainFiles" in optionsOrSourceConfig || "includeDev" in optionsOrSourceConfig)) {
+    sourceConfig = optionsOrSourceConfig.sourceConfig;
+    registry = optionsOrSourceConfig.registry;
+    sidecarPath = optionsOrSourceConfig.sidecarPath;
+    includeDev = optionsOrSourceConfig.includeDev ?? false;
+    domainFiles = optionsOrSourceConfig.domainFiles;
+  } else {
+    sourceConfig = optionsOrSourceConfig;
+  }
+  if (!registry) {
+    registry = createDefaultRegistry();
+  }
+  if (!sourceConfig && sidecarPath) {
+    const merged = loadMergedSourceConfig(rootPath, sidecarPath);
+    if (merged.ok) {
+      sourceConfig = merged.config;
+    }
+  }
+  return { sourceConfig, registry, includeDev, sidecarPath, domainFiles };
+}
+function processDiscoveredEntry(entry, ctx, acc) {
+  const { absPath, relativePath, kind } = entry;
+  const { registry, sourceConfig } = ctx;
+  try {
+    const manifest = parseManifest2(absPath);
+    if (!manifest) {
+      acc.errors.push({ path: relativePath, error: "Failed to parse manifest" });
+      return;
+    }
+    const publisher = resolvePublisher(relativePath, sourceConfig);
+    const name = deriveName(relativePath, kind, manifest);
+    const version = coerceVersion(manifest.version);
+    const ref = `${publisher}/${name}@${version}`;
+    const fileFilter = registry.defaultFileFilter(kind, absPath) ?? {
+      assetRoot: path.dirname(absPath),
+      files: [path.basename(absPath)]
+    };
+    const sha256 = computeDeterministicHash(fileFilter.assetRoot, fileFilter.files);
+    const requires = registry.extractRequires(kind, ref, manifest);
+    acc.allEdges.push(...requires);
+    acc.assets.push({
+      ref,
+      kind,
+      publisher,
+      name,
+      version,
+      manifest,
+      manifestPath: absPath,
+      relativePath,
+      fileFilter,
+      sha256,
+      requires
+    });
+  } catch (err) {
+    acc.errors.push({
+      path: relativePath,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
 }
 function* walkTree(rootDir) {
   function* walk(dir, relDir) {
@@ -1194,13 +1415,17 @@ async function discoverAssetsInTreeEntries(entries, options) {
     options.fetchBlob
   );
   const resolvedSourceConfig = options.sidecarSourceConfig ? mergeSourceConfigs(baseSourceConfig, options.sidecarSourceConfig) : baseSourceConfig;
+  const domainMds = options.domainFiles ? options.domainFiles.map((f) => parseDomainMd(f.path, parseDomainFrontmatter2(f.content))) : await collectDomainMdsFromTree(blobByPath, options.fetchBlob);
   if (resolvedSourceConfig && isManifestMode(resolvedSourceConfig)) {
-    return discoverFromManifestTree(
-      resolvedSourceConfig,
-      blobByPath,
-      options.fetchBlob,
-      registry,
-      includeDev
+    return finalizeDomains2(
+      await discoverFromManifestTree(
+        resolvedSourceConfig,
+        blobByPath,
+        options.fetchBlob,
+        registry,
+        includeDev
+      ),
+      domainMds
     );
   }
   const devPaths = resolvedSourceConfig?.dev_paths ?? [];
@@ -1210,86 +1435,130 @@ async function discoverAssetsInTreeEntries(entries, options) {
   const allEdges = [];
   const seen = /* @__PURE__ */ new Set();
   for (const relativePath of sortedBlobPaths) {
-    if (relativePath.startsWith(".git/") || relativePath.startsWith("node_modules/") || relativePath.startsWith(".skaile/") || relativePath.includes("/.git/") || relativePath.includes("/node_modules/") || relativePath.includes("/.skaile/")) {
-      continue;
-    }
-    if (!includeDev && isExcludedDevPath(relativePath, devPaths)) continue;
-    let kind;
-    try {
-      kind = registry.resolveKind(relativePath);
-    } catch (err) {
-      errors.push({
-        path: relativePath,
-        error: err instanceof Error ? err.message : String(err)
-      });
-      continue;
-    }
+    if (shouldSkipBlobPath(relativePath, includeDev, devPaths)) continue;
+    const kind = resolveKindForPath(relativePath, registry, errors);
     if (!kind) continue;
-    const dir = posixDirname(relativePath);
+    const dir = posixDirname2(relativePath);
     const dedupKey = `${dir}:${kind}`;
     if (seen.has(dedupKey)) continue;
     seen.add(dedupKey);
-    const manifestEntry = blobByPath.get(relativePath);
-    if (!manifestEntry) {
-      errors.push({ path: relativePath, error: "Manifest blob disappeared from tree index" });
-      continue;
-    }
-    let manifestBytes;
-    try {
-      manifestBytes = await fetchAsBuffer(options.fetchBlob, manifestEntry.sha);
-    } catch (err) {
-      errors.push({
-        path: relativePath,
-        error: `Failed to fetch manifest blob: ${err instanceof Error ? err.message : String(err)}`
-      });
-      continue;
-    }
-    if (!manifestBytes) {
-      errors.push({ path: relativePath, error: "Failed to fetch manifest blob" });
-      continue;
-    }
-    const manifestText = manifestBytes.toString("utf-8");
-    const manifest = parseManifestText(relativePath, manifestText);
-    if (!manifest) {
-      errors.push({ path: relativePath, error: "Failed to parse manifest" });
-      continue;
-    }
-    const publisher = resolvePublisher2(relativePath, resolvedSourceConfig);
-    const name = deriveName2(relativePath, kind, manifest);
-    const version = coerceVersion2(manifest.version);
-    const ref = `${publisher}/${name}@${version}`;
-    const fileFilter = computeFileFilter(kind, relativePath, blobByPath);
-    let sha256;
+    const result = await buildAssetFromBlob(
+      relativePath,
+      kind,
+      blobByPath,
+      options.fetchBlob,
+      resolvedSourceConfig,
+      registry,
+      errors
+    );
+    if (!result) continue;
+    allEdges.push(...result.requires);
+    assets.push(result);
+  }
+  const graph = buildRequiresGraph(allEdges);
+  return finalizeDomains2({ assets, graph, errors }, domainMds);
+}
+function parseDomainFrontmatter2(content) {
+  const { data } = parseFrontmatter(content);
+  return data && typeof data === "object" ? data : {};
+}
+async function collectDomainMdsFromTree(blobByPath, fetchBlob) {
+  const out = [];
+  for (const [p, entry] of blobByPath) {
+    if (!isDomainMdPath(p)) continue;
+    let bytes;
     try {
-      sha256 = await computeDeterministicHashFromTree(fileFilter, blobByPath, options.fetchBlob);
-    } catch (err) {
-      errors.push({
-        path: relativePath,
-        error: `Failed to compute hash: ${err instanceof Error ? err.message : String(err)}`
-      });
-      continue;
+      bytes = await fetchAsBuffer(fetchBlob, entry.sha);
+    } catch {
+      bytes = null;
     }
-    const requires = registry.extractRequires(kind, ref, manifest);
-    allEdges.push(...requires);
-    assets.push({
-      ref,
-      kind,
-      publisher,
-      name,
-      version,
-      manifest,
-      // The tree-entries variant has no on-disk path — surface the
-      // repo-relative path here so downstream consumers can build a
-      // Manifest URL (raw.githubusercontent.com link).
-      manifestPath: relativePath,
-      relativePath,
-      fileFilter,
-      sha256,
-      requires
+    if (bytes) out.push(parseDomainMd(p, parseDomainFrontmatter2(bytes.toString("utf-8"))));
+  }
+  return out;
+}
+function finalizeDomains2(result, domainMds) {
+  if (domainMds.length === 0) return result;
+  const { domains, errors } = applyDomains(result.assets, domainMds);
+  result.errors.push(...errors);
+  if (domains.length > 0) result.domains = domains;
+  return result;
+}
+function shouldSkipBlobPath(relativePath, includeDev, devPaths) {
+  if (relativePath.startsWith(".git/") || relativePath.startsWith("node_modules/") || relativePath.startsWith(".skaile/") || relativePath.includes("/.git/") || relativePath.includes("/node_modules/") || relativePath.includes("/.skaile/")) {
+    return true;
+  }
+  if (!includeDev && isExcludedDevPath(relativePath, devPaths)) return true;
+  return false;
+}
+function resolveKindForPath(relativePath, registry, errors) {
+  try {
+    return registry.resolveKind(relativePath);
+  } catch (err) {
+    errors.push({
+      path: relativePath,
+      error: err instanceof Error ? err.message : String(err)
     });
+    return void 0;
   }
-  const graph = buildRequiresGraph(allEdges);
-  return { assets, graph, errors };
+}
+async function buildAssetFromBlob(relativePath, kind, blobByPath, fetchBlob, resolvedSourceConfig, registry, errors) {
+  const manifestEntry = blobByPath.get(relativePath);
+  if (!manifestEntry) {
+    errors.push({ path: relativePath, error: "Manifest blob disappeared from tree index" });
+    return null;
+  }
+  let manifestBytes;
+  try {
+    manifestBytes = await fetchAsBuffer(fetchBlob, manifestEntry.sha);
+  } catch (err) {
+    errors.push({
+      path: relativePath,
+      error: `Failed to fetch manifest blob: ${err instanceof Error ? err.message : String(err)}`
+    });
+    return null;
+  }
+  if (!manifestBytes) {
+    errors.push({ path: relativePath, error: "Failed to fetch manifest blob" });
+    return null;
+  }
+  const manifestText = manifestBytes.toString("utf-8");
+  const manifest = parseManifestText(relativePath, manifestText);
+  if (!manifest) {
+    errors.push({ path: relativePath, error: "Failed to parse manifest" });
+    return null;
+  }
+  const publisher = resolvePublisher2(relativePath, resolvedSourceConfig);
+  const name = deriveName2(relativePath, kind, manifest);
+  const version = coerceVersion2(manifest.version);
+  const ref = `${publisher}/${name}@${version}`;
+  const fileFilter = computeFileFilter(kind, relativePath, blobByPath);
+  let sha256;
+  try {
+    sha256 = await computeDeterministicHashFromTree(fileFilter, blobByPath, fetchBlob);
+  } catch (err) {
+    errors.push({
+      path: relativePath,
+      error: `Failed to compute hash: ${err instanceof Error ? err.message : String(err)}`
+    });
+    return null;
+  }
+  const requires = registry.extractRequires(kind, ref, manifest);
+  return {
+    ref,
+    kind,
+    publisher,
+    name,
+    version,
+    manifest,
+    // The tree-entries variant has no on-disk path — surface the
+    // repo-relative path here so downstream consumers can build a
+    // Manifest URL (raw.githubusercontent.com link).
+    manifestPath: relativePath,
+    relativePath,
+    fileFilter,
+    sha256,
+    requires
+  };
 }
 function parseManifestText(relativePath, text) {
   try {
@@ -1359,7 +1628,7 @@ function deriveName2(relativePath, kind, manifest) {
   return filename.replace(/\.(md|yaml|json)$/, "");
 }
 function computeFileFilter(kind, manifestPath, blobByPath) {
-  const dir = posixDirname(manifestPath);
+  const dir = posixDirname2(manifestPath);
   const manifestName = posixBasename(manifestPath);
   switch (kind) {
     case "skill":
@@ -1443,7 +1712,7 @@ async function computeDeterministicHashFromTree(fileFilter, blobByPath, fetchBlo
   }
   return hash.digest("hex");
 }
-function posixDirname(p) {
+function posixDirname2(p) {
   const i = p.lastIndexOf("/");
   return i === -1 ? "" : p.slice(0, i);
 }
@@ -1508,6 +1777,72 @@ async function discoverFromManifestTree(sourceConfig, blobByPath, fetchBlob, reg
 }
 async function processManifestEntryTree(entry, blobByPath, fetchBlob, registry) {
   const errors = [];
+  const assetRootRelative = entry.path;
+  const files = resolveEntryFilesTree(entry, blobByPath, errors);
+  if (!files) return { asset: null, errors };
+  const manifestFileRel = pickManifestFileTree(entry.path, files, entry.kind, registry);
+  const manifestFull = joinPosix(entry.path, manifestFileRel);
+  const manifest = await fetchAndParseManifestTree(
+    manifestFull,
+    manifestFileRel,
+    assetRootRelative,
+    blobByPath,
+    fetchBlob,
+    errors
+  );
+  if (!manifest) return { asset: null, errors };
+  if (!registry.getProvider(entry.kind)) {
+    errors.push({
+      path: assetRootRelative,
+      error: `Unknown asset kind "${entry.kind}" \u2014 ghost-installing without provider validation`
+    });
+  }
+  const requiresErrors = validateRequiresSyntax2(entry.requires);
+  if (requiresErrors.length > 0) {
+    errors.push({
+      path: assetRootRelative,
+      error: `ManifestRequiresError: ${requiresErrors.join("; ")}`
+    });
+    return { asset: null, errors };
+  }
+  const computedHash = await computeAndVerifyHashTree(
+    entry,
+    files,
+    assetRootRelative,
+    blobByPath,
+    fetchBlob,
+    errors
+  );
+  if (computedHash === null) return { asset: null, errors };
+  const ref = `${entry.publisher}/${entry.name}@${entry.version}`;
+  const requires = entry.requires.map((to) => ({
+    from: ref,
+    to,
+    field: "assets[].requires"
+  }));
+  const mergedManifest = {
+    ...entry.metadata ?? {},
+    ...manifest
+  };
+  const asset = {
+    ref,
+    kind: entry.kind,
+    publisher: entry.publisher,
+    name: entry.name,
+    version: entry.version,
+    manifest: mergedManifest,
+    manifestPath: manifestFull,
+    relativePath: manifestFull,
+    fileFilter: {
+      assetRoot: entry.path,
+      files: [...files].sort()
+    },
+    sha256: computedHash,
+    requires
+  };
+  return { asset, errors };
+}
+function resolveEntryFilesTree(entry, blobByPath, errors) {
   const assetRootRelative = entry.path;
   const files = entry.files ?? expandRootFilesTree(entry.path, blobByPath);
   if (entry.files === void 0 && files.length === 0) {
@@ -1515,7 +1850,7 @@ async function processManifestEntryTree(entry, blobByPath, fetchBlob, registry)
       path: assetRootRelative,
       error: `ManifestFileMissing: root "${entry.root ?? entry.path}" contains no files`
     });
-    return { asset: null, errors };
+    return null;
   }
   const missing = [];
   for (const file of files) {
@@ -1527,10 +1862,11 @@ async function processManifestEntryTree(entry, blobByPath, fetchBlob, registry)
       path: assetRootRelative,
       error: `ManifestFileMissing: ${missing.join(", ")}`
     });
-    return { asset: null, errors };
+    return null;
   }
-  const manifestFileRel = pickManifestFileTree(entry.path, files, entry.kind, registry);
-  const manifestFull = joinPosix(entry.path, manifestFileRel);
+  return files;
+}
+async function fetchAndParseManifestTree(manifestFull, manifestFileRel, assetRootRelative, blobByPath, fetchBlob, errors) {
   const manifestEntry = blobByPath.get(manifestFull);
   let manifestBytes;
   try {
@@ -1540,14 +1876,14 @@ async function processManifestEntryTree(entry, blobByPath, fetchBlob, registry)
       path: assetRootRelative,
       error: `ManifestSchemaError: failed to fetch manifest blob: ${err instanceof Error ? err.message : String(err)}`
     });
-    return { asset: null, errors };
+    return null;
   }
   if (!manifestBytes) {
     errors.push({
       path: assetRootRelative,
       error: `ManifestSchemaError: failed to fetch manifest blob`
     });
-    return { asset: null, errors };
+    return null;
   }
   const manifest = parseManifestText(manifestFull, manifestBytes.toString("utf-8"));
   if (!manifest) {
@@ -1555,22 +1891,11 @@ async function processManifestEntryTree(entry, blobByPath, fetchBlob, registry)
       path: assetRootRelative,
       error: `ManifestSchemaError: failed to parse manifest file ${manifestFileRel}`
     });
-    return { asset: null, errors };
-  }
-  if (!registry.getProvider(entry.kind)) {
-    errors.push({
-      path: assetRootRelative,
-      error: `Unknown asset kind "${entry.kind}" \u2014 ghost-installing without provider validation`
-    });
-  }
-  const requiresErrors = validateRequiresSyntax2(entry.requires);
-  if (requiresErrors.length > 0) {
-    errors.push({
-      path: assetRootRelative,
-      error: `ManifestRequiresError: ${requiresErrors.join("; ")}`
-    });
-    return { asset: null, errors };
+    return null;
   }
+  return manifest;
+}
+async function computeAndVerifyHashTree(entry, files, assetRootRelative, blobByPath, fetchBlob, errors) {
   let computedHash;
   try {
     computedHash = await computeManifestHashTree(entry.path, files, blobByPath, fetchBlob);
@@ -1579,14 +1904,14 @@ async function processManifestEntryTree(entry, blobByPath, fetchBlob, registry)
       path: assetRootRelative,
       error: `Failed to compute hash: ${err instanceof Error ? err.message : String(err)}`
     });
-    return { asset: null, errors };
+    return null;
   }
   if (entry.sha256 && entry.sha256 !== computedHash) {
     errors.push({
       path: assetRootRelative,
       error: `ManifestHashMismatch: declared ${entry.sha256}, computed ${computedHash}`
     });
-    return { asset: null, errors };
+    return null;
   }
   if (!entry.sha256) {
     errors.push({
@@ -1594,33 +1919,7 @@ async function processManifestEntryTree(entry, blobByPath, fetchBlob, registry)
       error: `Missing sha256 \u2014 computed ${computedHash}. Re-run \`skaile source build-manifest --write\` to pin it.`
     });
   }
-  const ref = `${entry.publisher}/${entry.name}@${entry.version}`;
-  const requires = entry.requires.map((to) => ({
-    from: ref,
-    to,
-    field: "assets[].requires"
-  }));
-  const mergedManifest = {
-    ...entry.metadata ?? {},
-    ...manifest
-  };
-  const asset = {
-    ref,
-    kind: entry.kind,
-    publisher: entry.publisher,
-    name: entry.name,
-    version: entry.version,
-    manifest: mergedManifest,
-    manifestPath: manifestFull,
-    relativePath: manifestFull,
-    fileFilter: {
-      assetRoot: entry.path,
-      files: [...files].sort()
-    },
-    sha256: computedHash,
-    requires
-  };
-  return { asset, errors };
+  return computedHash;
 }
 var MANIFEST_FILENAMES2 = /* @__PURE__ */ new Set([
   "SKILL.md",
@@ -1687,6 +1986,6 @@ function validateRequiresSyntax2(requires) {
 // discovery/src/index.ts
 var VERSION = "0.0.0";
 
-export { AssetKindRegistry, BUILTIN_PROVIDERS, SEMVER_RE, SourceConfigSchema, VERSION, agentProvider, buildRequiresGraph, computeDeterministicHash, computeDeterministicHashDetailed, connectorProvider, contractProvider, createDefaultRegistry, decodeManifestSourceConfig, detectCycles, discoverAssetsInTree, discoverAssetsInTreeEntries, discoverFromManifest, extractRequires, isExcludedDevPath, isManifestMode, loadMergedSourceConfig, loadSourceConfig, manifestToSourceConfig, mcpServerProvider, mergeSourceConfigs, parseSourceConfig, personaProvider, presetProvider, promptProvider, readManifestSourceConfig, rulesetProvider, skillProvider, validateSourceConfig };
-//# sourceMappingURL=chunk-JIQLLZ65.js.map
-//# sourceMappingURL=chunk-JIQLLZ65.js.map
+export { AssetKindRegistry, BUILTIN_PROVIDERS, DOMAIN_MD_FILENAME, SEMVER_RE, SourceConfigSchema, VERSION, agentProvider, assignDomain, buildDomainIndex, buildRequiresGraph, computeDeterministicHash, computeDeterministicHashDetailed, connectorProvider, contractProvider, createDefaultRegistry, decodeManifestSourceConfig, detectCycles, discoverAssetsInTree, discoverAssetsInTreeEntries, discoverFromManifest, extractRequires, isDomainMdPath, isExcludedDevPath, isManifestMode, loadMergedSourceConfig, loadSourceConfig, manifestToSourceConfig, mcpServerProvider, mergeSourceConfigs, parseDomainMd, parseSourceConfig, personaProvider, presetProvider, promptProvider, readManifestSourceConfig, rulesetProvider, skillProvider, validateDomains, validateSourceConfig };
+//# sourceMappingURL=chunk-7MANNJ3U.js.map
+//# sourceMappingURL=chunk-7MANNJ3U.js.map