@skaile/workspaces 0.49.0 → 0.52.0

package/dist/{chunk-JXHULIOA.js → chunk-UTHEIPEY.js}

@@ -1,6 +1,6 @@
 import { AssetKindRegistryFrozenError, AssetKindConflictError, AssetKindPatternConflictError, AssetKindPathAmbiguityError } from './chunk-JXT46QFC.js';
 import { decodeSkaileManifest, SKAILE_MANIFEST_FILENAME } from './chunk-DZCK7GRW.js';
-import { parseFrontmatter } from './chunk-6IDBWPK2.js';
+import { parseFrontmatter } from './chunk-BQCGFPHW.js';
 import { isValidAssetName } from './chunk-GEEW6SY2.js';
 import { validatePersona, validateRuleset, validateSkill, validateAgent, validateConnector, validateMcpServer, validateContract, validatePrompt, validatePreset } from './chunk-CU5Z7GH3.js';
 import * as fs from 'fs';
@@ -113,6 +113,20 @@ var AssetKindRegistry = class {
   }
 };
 
+// discovery/src/atomization-conventions.ts
+var SKILL_COMPANION_DIRS = [
+  "references",
+  "scripts",
+  "assets",
+  "templates",
+  "modes",
+  "bin",
+  "data",
+  "examples",
+  "hooks"
+];
+var AGENT_COMPANION_DIRS = ["knowledge", "prompts", "examples"];
+
 // discovery/src/requires-graph.ts
 function extractRequires(assetRef, kind, manifest) {
   const edges = [];
@@ -190,12 +204,16 @@ function extractAgentRequires(ref, m, edges) {
 function extractFlowRequires(ref, m, edges) {
   if (!Array.isArray(m.nodes)) return;
   for (const node of m.nodes) {
-    if (isObjectWithStringField(node, "skill")) {
-      edges.push({
-        from: ref,
-        to: node.skill,
-        field: "nodes[].skill"
-      });
+    if (typeof node !== "object" || node === null) continue;
+    const n = node;
+    const data = typeof n.data === "object" && n.data !== null ? n.data : {};
+    const skill = typeof data.skill === "string" ? data.skill : n.skill;
+    if (typeof skill === "string") {
+      edges.push({ from: ref, to: skill, field: "nodes[].data.skill" });
+    }
+    const subFlow = typeof data.flow === "string" ? data.flow : n.flow;
+    if (typeof subFlow === "string") {
+      edges.push({ from: ref, to: subFlow, field: "nodes[].data.flow" });
     }
   }
 }
@@ -237,31 +255,31 @@ function extractSkillRequires(ref, m, edges) {
 function findCyclePath(nodes, adj) {
   const visited = /* @__PURE__ */ new Set();
   const stack = /* @__PURE__ */ new Set();
-  const path6 = [];
+  const path8 = [];
   for (const start of nodes) {
     if (visited.has(start)) continue;
-    const cycle = dfs(start, adj, visited, stack, path6, nodes);
+    const cycle = dfs(start, adj, visited, stack, path8, nodes);
     if (cycle) return cycle;
   }
   return [...nodes];
 }
-function dfs(node, adj, visited, stack, path6, scope) {
+function dfs(node, adj, visited, stack, path8, scope) {
   visited.add(node);
   stack.add(node);
-  path6.push(node);
+  path8.push(node);
   for (const neighbor of adj.get(node) ?? []) {
     if (!scope.has(neighbor)) continue;
     if (stack.has(neighbor)) {
-      const cycleStart = path6.indexOf(neighbor);
-      return [...path6.slice(cycleStart), neighbor];
+      const cycleStart = path8.indexOf(neighbor);
+      return [...path8.slice(cycleStart), neighbor];
     }
     if (!visited.has(neighbor)) {
-      const result = dfs(neighbor, adj, visited, stack, path6, scope);
+      const result = dfs(neighbor, adj, visited, stack, path8, scope);
       if (result) return result;
     }
   }
   stack.delete(node);
-  path6.pop();
+  path8.pop();
   return null;
 }
 function isObjectWithStringField(val, field) {
@@ -303,10 +321,13 @@ function skillFilter(manifestPath) {
   for (const leaf of ["validator.py", "CLI.md"]) {
     if (fs.existsSync(path.join(dir, leaf))) files.push(leaf);
   }
-  files.push(...collectDirRecursive(dir, "references"));
+  const companions = new Set(SKILL_COMPANION_DIRS);
+  for (const sub of SKILL_COMPANION_DIRS) {
+    files.push(...collectDirRecursive(dir, sub));
+  }
   try {
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-      if (entry.isDirectory() && entry.name !== "references") {
+      if (entry.isDirectory() && !companions.has(entry.name)) {
         if (fs.existsSync(path.join(dir, entry.name, "SKILL.md"))) {
           files.push(...collectDirRecursive(dir, entry.name));
         }
@@ -324,7 +345,9 @@ function agentFilter(manifestPath) {
   for (const companion of ["SOUL.md", "RULES.md"]) {
     if (fs.existsSync(path.join(dir, companion))) files.push(companion);
   }
-  files.push(...collectDirRecursive(dir, "knowledge"));
+  for (const sub of AGENT_COMPANION_DIRS) {
+    files.push(...collectDirRecursive(dir, sub));
+  }
   files.sort();
   return { assetRoot: dir, files };
 }
@@ -814,7 +837,7 @@ function discoverFromManifest(rootPath, sourceConfig, registry, includeDev = fal
     }
   }
   const graph = buildRequiresGraph(allEdges);
-  return { assets, graph, errors };
+  return { assets, graph, errors, warnings: [] };
 }
 function processEntry(rootPath, entry, registry) {
   const errors = [];
@@ -1169,8 +1192,159 @@ function applyDomains(assets, domains) {
   );
   return { domains: ordered, errors };
 }
+var SCANNABLE_EXT = /* @__PURE__ */ new Set([".md", ".mdx", ".markdown", ".txt"]);
+function isNonLocal(token) {
+  return token.length === 0 || token.startsWith("#") || token.startsWith("//") || /^[a-z][a-z0-9+.-]*:/i.test(token);
+}
+function extractPathCandidates(text) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(/!?\[[^\]]*\]\(\s*<?([^)>\s]+)>?(?:\s+"[^"]*")?\s*\)/g)) {
+    if (m[1]) out.add(m[1]);
+  }
+  for (const m of text.matchAll(/`([^`\n]+)`/g)) {
+    const tok = m[1]?.trim();
+    if (tok) out.add(tok);
+  }
+  for (const m of text.matchAll(/(?:\.{0,2}\/)?(?:[\w.@-]+\/)+[\w.@-]*/g)) {
+    if (m[0]) out.add(m[0]);
+  }
+  return [...out];
+}
+function looksLikePath(token) {
+  if (isNonLocal(token)) return false;
+  const clean = token.split(/[#?]/, 1)[0] ?? token;
+  if (clean.length === 0) return false;
+  if (clean.includes("/")) return true;
+  return /\.[a-z0-9]{1,6}$/i.test(clean);
+}
+function cleanToken(token) {
+  const clean = (token.split(/[#?]/, 1)[0] ?? token).trim();
+  return clean.endsWith("/") ? clean.slice(0, -1) : clean;
+}
+function createNodeAssetFs(assetRoot) {
+  const listFilesUnder = (rel) => {
+    const full = path.join(assetRoot, rel);
+    let stat;
+    try {
+      stat = fs.statSync(full);
+    } catch {
+      return [];
+    }
+    if (!stat.isDirectory()) return [rel];
+    const out = [];
+    for (const entry of fs.readdirSync(full, { withFileTypes: true })) {
+      const childRel = path.posix.join(rel, entry.name);
+      if (entry.isDirectory()) out.push(...listFilesUnder(childRel));
+      else if (entry.isFile()) out.push(childRel);
+    }
+    return out;
+  };
+  return {
+    readText(rel) {
+      try {
+        return fs.readFileSync(path.join(assetRoot, rel), "utf-8");
+      } catch {
+        return null;
+      }
+    },
+    statKind(rel) {
+      try {
+        return fs.statSync(path.join(assetRoot, rel)).isDirectory() ? "dir" : "file";
+      } catch {
+        return "absent";
+      }
+    },
+    listFilesUnder
+  };
+}
+function toFs(assetRootOrFs) {
+  return typeof assetRootOrFs === "string" ? createNodeAssetFs(assetRootOrFs) : assetRootOrFs;
+}
+function scanAssetReferences(assetRootOrFs, includedFiles) {
+  const afs = toFs(assetRootOrFs);
+  const included = new Set(includedFiles);
+  const isCoveredDir = (rel) => includedFiles.some((f) => f.startsWith(`${rel}/`));
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const fromFile of includedFiles) {
+    if (!SCANNABLE_EXT.has(path.posix.extname(fromFile).toLowerCase())) continue;
+    const text = afs.readText(fromFile);
+    if (text === null) continue;
+    const fromDir = path.posix.dirname(fromFile);
+    for (const raw of extractPathCandidates(text)) {
+      if (!looksLikePath(raw)) continue;
+      const clean = cleanToken(raw);
+      if (clean.length === 0) continue;
+      const joined = path.posix.normalize(
+        fromDir === "." ? clean : path.posix.join(fromDir, clean)
+      );
+      const dedup = `${fromFile}\0${joined}`;
+      if (seen.has(dedup)) continue;
+      seen.add(dedup);
+      if (joined === ".." || joined.startsWith("../")) {
+        results.push({ fromFile, raw, resolved: joined, isDir: false, classification: "external" });
+        continue;
+      }
+      const kind = afs.statKind(joined);
+      if (kind === "absent") {
+        results.push({
+          fromFile,
+          raw,
+          resolved: joined,
+          isDir: false,
+          classification: "unresolved"
+        });
+        continue;
+      }
+      const isDir = kind === "dir";
+      const covered = isDir ? isCoveredDir(joined) : included.has(joined);
+      results.push({
+        fromFile,
+        raw,
+        resolved: joined,
+        isDir,
+        classification: covered ? "covered" : "uncovered-in-dir"
+      });
+    }
+  }
+  return results;
+}
+function closeOverReferences(assetRootOrFs, seedFiles) {
+  const afs = toFs(assetRootOrFs);
+  const included = new Set(seedFiles);
+  const added = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    let grew = false;
+    for (const r of scanAssetReferences(afs, [...included])) {
+      if (r.classification !== "uncovered-in-dir") continue;
+      for (const f of afs.listFilesUnder(r.resolved)) {
+        if (!included.has(f)) {
+          included.add(f);
+          added.add(f);
+          grew = true;
+        }
+      }
+    }
+    if (!grew) break;
+  }
+  return { files: [...included].sort(), added: [...added].sort() };
+}
+function lintUncoveredReferences(manifestRelPath, assetRootOrFs, includedFiles) {
+  const refs = scanAssetReferences(assetRootOrFs, includedFiles);
+  const targets = /* @__PURE__ */ new Map();
+  for (const r of refs) {
+    if (r.classification === "uncovered-in-dir" && !targets.has(r.resolved)) {
+      targets.set(r.resolved, r.raw);
+    }
+  }
+  return [...targets.entries()].map(([resolved, raw]) => ({
+    path: manifestRelPath,
+    warning: `references "${raw}" \u2192 ${resolved}, which exists in the asset directory but is not captured by the file filter`
+  }));
+}
 
 // discovery/src/discover.ts
+var DEFAULT_ATOMIZATION_POLICY = "strict";
 function createDefaultRegistry() {
   const registry = new AssetKindRegistry();
   for (const provider of BUILTIN_PROVIDERS) {
@@ -1179,10 +1353,7 @@ function createDefaultRegistry() {
   return registry;
 }
 function discoverAssetsInTree(rootPath, optionsOrSourceConfig) {
-  const { sourceConfig, registry, includeDev, sidecarPath, domainFiles } = normalizeDiscoveryArgs(
-    rootPath,
-    optionsOrSourceConfig
-  );
+  const { sourceConfig, registry, includeDev, sidecarPath, domainFiles, atomization } = normalizeDiscoveryArgs(rootPath, optionsOrSourceConfig);
   const domainMds = domainFiles ? domainFiles.map((f) => parseDomainMd(f.path, parseDomainFrontmatter(f.content))) : collectDomainMds(sidecarPath ?? rootPath);
   if (sourceConfig && isManifestMode(sourceConfig)) {
     return finalizeDomains(
@@ -1192,6 +1363,7 @@ function discoverAssetsInTree(rootPath, optionsOrSourceConfig) {
   }
   const assets = [];
   const errors = [];
+  const warnings = [];
   const allEdges = [];
   const devPaths = sourceConfig?.dev_paths ?? [];
   const seen = /* @__PURE__ */ new Set();
@@ -1214,12 +1386,13 @@ function discoverAssetsInTree(rootPath, optionsOrSourceConfig) {
     seen.add(dedupKey);
     processDiscoveredEntry(
       { absPath, relativePath, kind },
-      { registry, sourceConfig },
-      { assets, errors, allEdges }
+      { registry, sourceConfig, atomization },
+      { assets, errors, warnings, allEdges }
     );
   }
+  allEdges.push(...extractBodyLinkEdges(assets));
   const graph = buildRequiresGraph(allEdges);
-  return finalizeDomains({ assets, graph, errors }, domainMds);
+  return finalizeDomains({ assets, graph, errors, warnings }, domainMds);
 }
 function parseDomainFrontmatter(content) {
   const { data } = parseFrontmatter(content);
@@ -1251,12 +1424,14 @@ function normalizeDiscoveryArgs(rootPath, optionsOrSourceConfig) {
   let sidecarPath;
   let includeDev = false;
   let domainFiles;
-  if (optionsOrSourceConfig && ("registry" in optionsOrSourceConfig || "sourceConfig" in optionsOrSourceConfig || "sidecarPath" in optionsOrSourceConfig || "domainFiles" in optionsOrSourceConfig || "includeDev" in optionsOrSourceConfig)) {
+  let atomization = DEFAULT_ATOMIZATION_POLICY;
+  if (optionsOrSourceConfig && ("registry" in optionsOrSourceConfig || "sourceConfig" in optionsOrSourceConfig || "sidecarPath" in optionsOrSourceConfig || "domainFiles" in optionsOrSourceConfig || "atomization" in optionsOrSourceConfig || "includeDev" in optionsOrSourceConfig)) {
     sourceConfig = optionsOrSourceConfig.sourceConfig;
     registry = optionsOrSourceConfig.registry;
     sidecarPath = optionsOrSourceConfig.sidecarPath;
     includeDev = optionsOrSourceConfig.includeDev ?? false;
     domainFiles = optionsOrSourceConfig.domainFiles;
+    atomization = optionsOrSourceConfig.atomization ?? DEFAULT_ATOMIZATION_POLICY;
   } else {
     sourceConfig = optionsOrSourceConfig;
   }
@@ -1269,11 +1444,11 @@ function normalizeDiscoveryArgs(rootPath, optionsOrSourceConfig) {
       sourceConfig = merged.config;
     }
   }
-  return { sourceConfig, registry, includeDev, sidecarPath, domainFiles };
+  return { sourceConfig, registry, includeDev, sidecarPath, domainFiles, atomization };
 }
 function processDiscoveredEntry(entry, ctx, acc) {
   const { absPath, relativePath, kind } = entry;
-  const { registry, sourceConfig } = ctx;
+  const { registry, sourceConfig, atomization } = ctx;
   try {
     const manifest = parseManifest2(absPath);
     if (!manifest) {
@@ -1288,6 +1463,7 @@ function processDiscoveredEntry(entry, ctx, acc) {
       assetRoot: path.dirname(absPath),
       files: [path.basename(absPath)]
     };
+    applyAtomizationPolicy(atomization, relativePath, fileFilter, registry, acc.warnings);
     const sha256 = computeDeterministicHash(fileFilter.assetRoot, fileFilter.files);
     const requires = registry.extractRequires(kind, ref, manifest);
     acc.allEdges.push(...requires);
@@ -1311,6 +1487,61 @@ function processDiscoveredEntry(entry, ctx, acc) {
     });
   }
 }
+function applyAtomizationPolicy(policy, relativePath, fileFilter, registry, warnings) {
+  if (policy === "strict") {
+    warnings.push(...lintUncoveredReferences(relativePath, fileFilter.assetRoot, fileFilter.files));
+    return;
+  }
+  const structural = new Set(fileFilter.files);
+  const expanded = policy === "full-dir" ? collectFullDirFiles(fileFilter.assetRoot, registry) : closeOverReferences(fileFilter.assetRoot, fileFilter.files).files;
+  fileFilter.files = expanded;
+  const reason = policy === "full-dir" ? "full-dir capture" : "reference closure (referenced but uncaptured)";
+  for (const f of expanded) {
+    if (!structural.has(f)) {
+      warnings.push({ path: relativePath, warning: `captured "${f}" via ${reason}` });
+    }
+  }
+}
+function collectFullDirFiles(assetRoot, registry) {
+  const all = [];
+  const nestedDirs = [];
+  for (const { relativePath } of walkTree(assetRoot)) {
+    all.push(relativePath);
+    const dir = path.posix.dirname(relativePath);
+    if (dir === ".") continue;
+    let kind;
+    try {
+      kind = registry.resolveKind(relativePath);
+    } catch {
+      kind = void 0;
+    }
+    if (kind) nestedDirs.push(dir);
+  }
+  const carved = [...new Set(nestedDirs)];
+  const inCarvedSubtree = (file) => carved.some((d) => file.startsWith(`${d}/`));
+  return all.filter((f) => !inCarvedSubtree(f)).sort();
+}
+function extractBodyLinkEdges(assets) {
+  const roots = assets.map((a) => ({ root: a.fileFilter.assetRoot, ref: a.ref })).sort((x, y) => y.root.length - x.root.length);
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const asset of assets) {
+    const root = asset.fileFilter.assetRoot;
+    for (const r of scanAssetReferences(root, asset.fileFilter.files)) {
+      if (r.classification !== "external") continue;
+      const target = path.resolve(root, r.resolved);
+      const hit = roots.find(
+        (cand) => cand.ref !== asset.ref && (target === cand.root || target.startsWith(`${cand.root}${path.sep}`))
+      );
+      if (!hit) continue;
+      const key = `${asset.ref}\0${hit.ref}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push({ from: asset.ref, to: hit.ref, field: "body-link" });
+    }
+  }
+  return edges;
+}
 function* walkTree(rootDir) {
   function* walk(dir, relDir) {
     let entries;
@@ -1409,6 +1640,7 @@ function deriveName(relativePath, kind, manifest) {
 async function discoverAssetsInTreeEntries(entries, options) {
   const registry = options.registry ?? createDefaultRegistry();
   const includeDev = options.includeDev ?? false;
+  const atomization = options.atomization ?? DEFAULT_ATOMIZATION_POLICY;
   const blobByPath = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (entry.type === "blob") {
@@ -1438,6 +1670,7 @@ async function discoverAssetsInTreeEntries(entries, options) {
   const sortedBlobPaths = [...blobByPath.keys()].sort();
   const assets = [];
   const errors = [];
+  const warnings = [];
   const allEdges = [];
   const seen = /* @__PURE__ */ new Set();
   for (const relativePath of sortedBlobPaths) {
@@ -1455,14 +1688,17 @@ async function discoverAssetsInTreeEntries(entries, options) {
       options.fetchBlob,
       resolvedSourceConfig,
       registry,
-      errors
+      atomization,
+      errors,
+      warnings
     );
     if (!result) continue;
     allEdges.push(...result.requires);
     assets.push(result);
   }
+  allEdges.push(...await extractBodyLinkEdgesTree(assets, blobByPath, options.fetchBlob));
   const graph = buildRequiresGraph(allEdges);
-  return finalizeDomains2({ assets, graph, errors }, domainMds);
+  return finalizeDomains2({ assets, graph, errors, warnings }, domainMds);
 }
 function parseDomainFrontmatter2(content) {
   const { data } = parseFrontmatter(content);
@@ -1507,7 +1743,7 @@ function resolveKindForPath(relativePath, registry, errors) {
     return void 0;
   }
 }
-async function buildAssetFromBlob(relativePath, kind, blobByPath, fetchBlob, resolvedSourceConfig, registry, errors) {
+async function buildAssetFromBlob(relativePath, kind, blobByPath, fetchBlob, resolvedSourceConfig, registry, atomization, errors, warnings) {
   const manifestEntry = blobByPath.get(relativePath);
   if (!manifestEntry) {
     errors.push({ path: relativePath, error: "Manifest blob disappeared from tree index" });
@@ -1538,6 +1774,16 @@ async function buildAssetFromBlob(relativePath, kind, blobByPath, fetchBlob, res
   const version = coerceVersion2(manifest);
   const ref = `${publisher}/${name}@${version}`;
   const fileFilter = computeFileFilter(kind, relativePath, blobByPath);
+  warnings.push(
+    ...await applyAtomizationPolicyTree(
+      atomization,
+      relativePath,
+      fileFilter,
+      blobByPath,
+      fetchBlob,
+      registry
+    )
+  );
   let sha256;
   try {
     sha256 = await computeDeterministicHashFromTree(fileFilter, blobByPath, fetchBlob);
@@ -1667,14 +1913,14 @@ function skillFilterVirtual(dir, manifestName, blobByPath) {
     const remainder = blobPath.slice(dir === "" ? 0 : dir.length + 1);
     const slash = remainder.indexOf("/");
     if (slash === -1) continue;
-    const childDir = remainder.slice(0, slash);
-    directChildDirs.add(childDir);
+    directChildDirs.add(remainder.slice(0, slash));
   }
-  if (directChildDirs.has("references")) {
-    addAllUnder(files, dir, "references", blobByPath);
+  const companions = new Set(SKILL_COMPANION_DIRS);
+  for (const sub of SKILL_COMPANION_DIRS) {
+    if (directChildDirs.has(sub)) addAllUnder(files, dir, sub, blobByPath);
   }
   for (const childDir of directChildDirs) {
-    if (childDir === "references") continue;
+    if (companions.has(childDir)) continue;
     if (blobByPath.has(joinPosix(dir, childDir, "SKILL.md"))) {
       addAllUnder(files, dir, childDir, blobByPath);
     }
@@ -1686,7 +1932,9 @@ function agentFilterVirtual(dir, manifestName, blobByPath) {
   for (const companion of ["SOUL.md", "RULES.md"]) {
     if (blobByPath.has(joinPosix(dir, companion))) files.add(companion);
   }
-  addAllUnder(files, dir, "knowledge", blobByPath);
+  for (const sub of AGENT_COMPANION_DIRS) {
+    addAllUnder(files, dir, sub, blobByPath);
+  }
   return { assetRoot: dir, files: [...files].sort() };
 }
 function contractFilterVirtual(dir, manifestName, blobByPath) {
@@ -1724,6 +1972,103 @@ async function computeDeterministicHashFromTree(fileFilter, blobByPath, fetchBlo
   }
   return hash.digest("hex");
 }
+var TREE_SCANNABLE_EXT = /* @__PURE__ */ new Set([".md", ".mdx", ".markdown", ".txt"]);
+async function prefetchAssetText(assetRoot, blobByPath, fetchBlob) {
+  const prefix = assetRoot === "" ? "" : `${assetRoot}/`;
+  const out = /* @__PURE__ */ new Map();
+  for (const [full, entry] of blobByPath) {
+    if (assetRoot !== "" && !full.startsWith(prefix)) continue;
+    if (!TREE_SCANNABLE_EXT.has(path.posix.extname(full).toLowerCase())) continue;
+    let bytes;
+    try {
+      bytes = await fetchAsBuffer(fetchBlob, entry.sha);
+    } catch {
+      bytes = null;
+    }
+    if (bytes) out.set(full, bytes.toString("utf-8"));
+  }
+  return out;
+}
+function createTreeAssetFs(assetRoot, blobByPath, textByPath) {
+  const full = (rel) => joinPosix(assetRoot, rel);
+  return {
+    readText(rel) {
+      return textByPath.get(full(rel)) ?? null;
+    },
+    statKind(rel) {
+      const f = full(rel);
+      if (blobByPath.has(f)) return "file";
+      const dirPrefix = `${f}/`;
+      for (const k of blobByPath.keys()) if (k.startsWith(dirPrefix)) return "dir";
+      return "absent";
+    },
+    listFilesUnder(rel) {
+      const f = full(rel);
+      if (blobByPath.has(f)) return [rel];
+      const dirPrefix = `${f}/`;
+      const out = [];
+      for (const k of blobByPath.keys()) {
+        if (k.startsWith(dirPrefix)) out.push(assetRoot === "" ? k : k.slice(assetRoot.length + 1));
+      }
+      return out;
+    }
+  };
+}
+function collectFullDirFilesTree(assetRoot, blobByPath, registry) {
+  const prefix = assetRoot === "" ? "" : `${assetRoot}/`;
+  const all = [];
+  const nestedDirs = [];
+  for (const full of blobByPath.keys()) {
+    if (assetRoot !== "" && !full.startsWith(prefix)) continue;
+    const rel = assetRoot === "" ? full : full.slice(assetRoot.length + 1);
+    all.push(rel);
+    if (rel.includes("/")) {
+      let kind;
+      try {
+        kind = registry.resolveKind(rel);
+      } catch {
+        kind = void 0;
+      }
+      if (kind) nestedDirs.push(posixDirname2(rel));
+    }
+  }
+  const carved = [...new Set(nestedDirs)];
+  return all.filter((rel) => !carved.some((d) => rel.startsWith(`${d}/`))).sort();
+}
+async function applyAtomizationPolicyTree(policy, relativePath, fileFilter, blobByPath, fetchBlob, registry) {
+  const textByPath = await prefetchAssetText(fileFilter.assetRoot, blobByPath, fetchBlob);
+  const afs = createTreeAssetFs(fileFilter.assetRoot, blobByPath, textByPath);
+  if (policy === "strict") {
+    return lintUncoveredReferences(relativePath, afs, fileFilter.files);
+  }
+  const structural = new Set(fileFilter.files);
+  fileFilter.files = policy === "full-dir" ? collectFullDirFilesTree(fileFilter.assetRoot, blobByPath, registry) : closeOverReferences(afs, fileFilter.files).files;
+  const reason = policy === "full-dir" ? "full-dir capture" : "reference closure (referenced but uncaptured)";
+  return fileFilter.files.filter((f) => !structural.has(f)).map((f) => ({ path: relativePath, warning: `captured "${f}" via ${reason}` }));
+}
+async function extractBodyLinkEdgesTree(assets, blobByPath, fetchBlob) {
+  const roots = assets.map((a) => ({ root: a.fileFilter.assetRoot, ref: a.ref })).sort((x, y) => y.root.length - x.root.length);
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const asset of assets) {
+    const root = asset.fileFilter.assetRoot;
+    const textByPath = await prefetchAssetText(root, blobByPath, fetchBlob);
+    const afs = createTreeAssetFs(root, blobByPath, textByPath);
+    for (const r of scanAssetReferences(afs, asset.fileFilter.files)) {
+      if (r.classification !== "external") continue;
+      const target = path.posix.normalize(joinPosix(root, r.resolved));
+      const hit = roots.find(
+        (cand) => cand.ref !== asset.ref && (target === cand.root || target.startsWith(`${cand.root}/`))
+      );
+      if (!hit) continue;
+      const key = `${asset.ref} ${hit.ref}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push({ from: asset.ref, to: hit.ref, field: "body-link" });
+    }
+  }
+  return edges;
+}
 function posixDirname2(p) {
   const i = p.lastIndexOf("/");
   return i === -1 ? "" : p.slice(0, i);
@@ -1785,7 +2130,7 @@ async function discoverFromManifestTree(sourceConfig, blobByPath, fetchBlob, reg
     }
   }
   const graph = buildRequiresGraph(allEdges);
-  return { assets, graph, errors };
+  return { assets, graph, errors, warnings: [] };
 }
 async function processManifestEntryTree(entry, blobByPath, fetchBlob, registry) {
   const errors = [];
@@ -1998,6 +2343,6 @@ function validateRequiresSyntax2(requires) {
 // discovery/src/index.ts
 var VERSION = "0.0.0";
 
-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-JXHULIOA.js.map
-//# sourceMappingURL=chunk-JXHULIOA.js.map
+export { AGENT_COMPANION_DIRS, AssetKindRegistry, BUILTIN_PROVIDERS, DEFAULT_ATOMIZATION_POLICY, DOMAIN_MD_FILENAME, SEMVER_RE, SKILL_COMPANION_DIRS, SourceConfigSchema, VERSION, agentProvider, assignDomain, buildDomainIndex, buildRequiresGraph, closeOverReferences, computeDeterministicHash, computeDeterministicHashDetailed, connectorProvider, contractProvider, createDefaultRegistry, createNodeAssetFs, decodeManifestSourceConfig, detectCycles, discoverAssetsInTree, discoverAssetsInTreeEntries, discoverFromManifest, extractPathCandidates, extractRequires, isDomainMdPath, isExcludedDevPath, isManifestMode, lintUncoveredReferences, loadMergedSourceConfig, loadSourceConfig, manifestToSourceConfig, mcpServerProvider, mergeSourceConfigs, parseDomainMd, parseSourceConfig, personaProvider, presetProvider, promptProvider, readManifestSourceConfig, rulesetProvider, scanAssetReferences, skillProvider, validateDomains, validateSourceConfig };
+//# sourceMappingURL=chunk-UTHEIPEY.js.map
+//# sourceMappingURL=chunk-UTHEIPEY.js.map