@sixb/core 0.1.16 → 0.1.18

package/dist/{chunk-a7ne02hk.js → chunk-s4jhg8a3.js}

@@ -1,40 +1,43 @@
 // @bun
+import {
+  assertPredicateShape,
+  createPropertyPredicateBuilder,
+  createLinkPredicateBuilder,
+  allPredicates,
+  anyPredicates,
+  notPredicate,
+  isScheduleDefinition2
+} from "./chunk-e1c18xjx.js";
 import {
   isActionDefinition2,
-  isGroupDefinition,
-  isMembershipPolicyDefinition,
-  isRoleDefinition,
   ShareDefinitionError2,
   isShareDefinition,
   snapshotShareDefinition
-} from "./chunk-2xvgy3x5.js";
+} from "./chunk-6h5m9xjx.js";
 import {
   isProjectionDefinition2
-} from "./chunk-69kt9q43.js";
+} from "./chunk-qkbx3tf6.js";
+import {
+  isMarkingDefinition,
+  isGroupDefinition,
+  isMembershipPolicyDefinition,
+  isRoleDefinition
+} from "./chunk-xt1zt7gv.js";
 import {
   isDatasetDefinition2
-} from "./chunk-cd234ba4.js";
+} from "./chunk-rz53yb4v.js";
 import {
   isPipelineDefinition2
-} from "./chunk-h866d223.js";
-import {
-  assertPredicateShape,
-  createPropertyPredicateBuilder,
-  createLinkPredicateBuilder,
-  allPredicates,
-  anyPredicates,
-  notPredicate,
-  isScheduleDefinition2
-} from "./chunk-e1c18xjx.js";
+} from "./chunk-qkvz64nd.js";
 import {
   isSyncDefinition2
-} from "./chunk-zb47r1c8.js";
+} from "./chunk-zb77kjth.js";
 import {
   isWorkflowDefinition2
-} from "./chunk-3q7z9hd4.js";
+} from "./chunk-fe52eczz.js";
 import {
   compileShareAccessPlan
-} from "./chunk-cxj8y8t0.js";
+} from "./chunk-za5yd58j.js";
 import {
   isConnectorDefinition
 } from "./chunk-9x8dybsb.js";
@@ -42,11 +45,262 @@ import {
   RuntimeError2
 } from "./chunk-m4ehq95f.js";
 
-// src/bootstrap/discovery.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { readdir } from "fs/promises";
-import { join, relative, resolve } from "path";
-import { pathToFileURL } from "url";
+// src/bootstrap/agent-context.ts
+import { lstat, readdir, readFile, stat } from "fs/promises";
+import { basename, join, relative, sep } from "path";
+var PROJECT_INSTRUCTIONS_FILE = "SIXB.md";
+var MAX_PROJECT_INSTRUCTIONS_BYTES = 32 * 1024;
+var MAX_AGENT_FILES_BYTES = 16 * 1024 * 1024;
+var IGNORED_NAMES = new Set(["node_modules", "venv", "__pycache__"]);
+var SKILL_NAME_RE = /^[a-z0-9][a-z0-9._-]*$/;
+var UNQUOTED_COLON_VALUE_RE = /^\s*[\w-]+:\s+[^\s"'|>].*:\s/;
+function isAgentContextPath2(path) {
+  const segments = path.split("/");
+  if (segments.some(isIgnoredAgentContextName))
+    return false;
+  if (path === PROJECT_INSTRUCTIONS_FILE || segments[0] === "skills")
+    return true;
+  if (segments[0] !== "ontology")
+    return false;
+  return isMarkdown(path) || segments.slice(1, -1).some(isOntologyScriptsDirectory);
+}
+function isIgnoredAgentContextName(name) {
+  return name.startsWith(".") || IGNORED_NAMES.has(name);
+}
+function isOntologyScriptsDirectory(name) {
+  return name === "scripts";
+}
+async function discoverOntologyFiles(projectRoot) {
+  const ontologyDir = join(projectRoot, "ontology");
+  const docs = [];
+  const scripts = [];
+  const budget = createFilesBudget("ontology/");
+  async function walk(dir, inScripts) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch (error) {
+      if (isNotFound(error))
+        return;
+      throw error;
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (isIgnoredAgentContextName(entry.name))
+        continue;
+      const path = join(dir, entry.name);
+      const relativePath = toPosixRelative(ontologyDir, path);
+      if (entry.isSymbolicLink()) {
+        const target = await stat(path).catch(() => {
+          return;
+        });
+        if (inScripts || isMarkdown(entry.name) || target?.isDirectory()) {
+          throw new RuntimeError2(`[Sixb] Ontology path 'ontology/${relativePath}' must not be a symlink.`);
+        }
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await walk(path, inScripts || isOntologyScriptsDirectory(entry.name));
+        continue;
+      }
+      if (!entry.isFile() || !(inScripts || isMarkdown(entry.name)))
+        continue;
+      const info = await lstat(path);
+      budget(info.size);
+      if (inScripts) {
+        const mode = info.mode & 511;
+        scripts.push(Object.freeze({
+          path: relativePath,
+          contents: await readFile(path),
+          ...(mode & 73) === 0 ? {} : { mode }
+        }));
+      } else {
+        const contents = decodeUtf8(await readFile(path));
+        if (contents === undefined) {
+          throw new RuntimeError2(`[Sixb] Ontology doc 'ontology/${relativePath}' must be UTF-8 text.`);
+        }
+        docs.push(Object.freeze({ path: relativePath, contents }));
+      }
+    }
+  }
+  await walk(ontologyDir, false);
+  return { docs, scripts };
+}
+async function discoverAgentSkills(projectRoot) {
+  const skillsDir = join(projectRoot, "skills");
+  let entries;
+  try {
+    entries = await readdir(skillsDir);
+  } catch (error) {
+    if (isNotFound(error))
+      return [];
+    throw error;
+  }
+  const skills = [];
+  const budget = createFilesBudget("skills/");
+  for (const entry of entries.sort((a, b) => a.localeCompare(b))) {
+    if (isIgnoredAgentContextName(entry))
+      continue;
+    const skillDir = join(skillsDir, entry);
+    const info = await lstat(skillDir);
+    if (info.isSymbolicLink()) {
+      throw skillError(projectRoot, skillDir, "Skill directories must not be symlinks.");
+    }
+    if (!info.isDirectory())
+      continue;
+    skills.push(await loadAgentSkill(projectRoot, skillDir, budget));
+  }
+  return skills;
+}
+async function discoverProjectInstructions(projectRoot) {
+  const path = join(projectRoot, PROJECT_INSTRUCTIONS_FILE);
+  let info;
+  try {
+    info = await lstat(path);
+  } catch (error) {
+    if (isNotFound(error))
+      return;
+    throw error;
+  }
+  if (!info.isFile()) {
+    throw instructionsError("must be a regular file, not a symlink or a directory.");
+  }
+  if (info.size > MAX_PROJECT_INSTRUCTIONS_BYTES) {
+    throw instructionsError(`is ${info.size.toLocaleString("en-US")} bytes; the limit is ` + `${MAX_PROJECT_INSTRUCTIONS_BYTES.toLocaleString("en-US")}. It is part of every ` + "conversation's prompt: keep it to project-wide guidance and move task-specific " + "instructions into skills/, which the agent reads only when relevant.");
+  }
+  const instructions = decodeUtf8(await readFile(path));
+  if (instructions === undefined)
+    throw instructionsError("must be UTF-8 text.");
+  if (!instructions.trim()) {
+    throw instructionsError("is empty. Write the agent's project instructions or delete the file.");
+  }
+  return instructions;
+}
+async function loadAgentSkill(projectRoot, skillDir, budget) {
+  const files = await collectSkillFiles(projectRoot, skillDir, budget);
+  const skillFile = files.find((file) => file.path === "SKILL.md");
+  if (!skillFile || typeof skillFile.contents !== "string") {
+    throw skillError(projectRoot, skillDir, "Missing required regular SKILL.md.");
+  }
+  const metadata = parseSkillMetadata(projectRoot, skillDir, skillFile.contents);
+  validateSkillMetadata(projectRoot, skillDir, metadata);
+  return Object.freeze({
+    name: metadata.name,
+    description: metadata.description,
+    files: Object.freeze(files)
+  });
+}
+function validateSkillMetadata(projectRoot, skillDir, metadata) {
+  const fail = (message) => skillError(projectRoot, skillDir, message);
+  if (!metadata.name?.trim()) {
+    throw fail("SKILL.md frontmatter must include a non-empty string name.");
+  }
+  if (!metadata.description?.trim()) {
+    throw fail("SKILL.md frontmatter must include a non-empty string description.");
+  }
+  if (!SKILL_NAME_RE.test(metadata.name)) {
+    throw fail(`Skill name '${metadata.name}' must match ${String(SKILL_NAME_RE)}.`);
+  }
+  const dirName = basename(skillDir);
+  if (metadata.name !== dirName) {
+    throw fail(`Skill name '${metadata.name}' must match directory '${dirName}'.`);
+  }
+  if (metadata.name.startsWith("sixb-")) {
+    throw fail(`Skill name '${metadata.name}' uses the reserved 'sixb-' prefix.`);
+  }
+}
+async function collectSkillFiles(projectRoot, skillDir, budget, currentDir = skillDir) {
+  const files = [];
+  const entries = await readdir(currentDir);
+  for (const entry of entries.sort((a, b) => a.localeCompare(b))) {
+    if (isIgnoredAgentContextName(entry))
+      continue;
+    const path = join(currentDir, entry);
+    const info = await lstat(path);
+    const relativePath = toPosixRelative(skillDir, path);
+    if (info.isSymbolicLink()) {
+      throw skillError(projectRoot, skillDir, `Skill file '${relativePath}' must not be a symlink.`);
+    }
+    if (info.isDirectory()) {
+      files.push(...await collectSkillFiles(projectRoot, skillDir, budget, path));
+      continue;
+    }
+    if (!info.isFile())
+      continue;
+    budget(info.size);
+    const mode = info.mode & 511;
+    files.push(Object.freeze({
+      path: relativePath,
+      contents: relativePath === "SKILL.md" ? await readFile(path, "utf-8") : await readFile(path),
+      ...(mode & 73) === 0 ? {} : { mode }
+    }));
+  }
+  return files;
+}
+function parseSkillMetadata(projectRoot, skillDir, markdown) {
+  const fail = (message) => skillError(projectRoot, skillDir, message);
+  const lines = markdown.replaceAll(`\r
+`, `
+`).split(`
+`);
+  if (lines[0] !== "---") {
+    throw fail("SKILL.md must start with YAML frontmatter delimited by ---.");
+  }
+  const end = lines.findIndex((line, index) => index > 0 && line === "---");
+  if (end < 0) {
+    throw fail("SKILL.md frontmatter is missing the closing --- delimiter.");
+  }
+  const frontmatter = lines.slice(1, end);
+  let parsed;
+  try {
+    parsed = Bun.YAML.parse(frontmatter.join(`
+`));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const hint = frontmatter.some((line) => UNQUOTED_COLON_VALUE_RE.test(line)) ? ` Quote values that contain ': ', for example description: "Use when: ...".` : "";
+    throw fail(`SKILL.md frontmatter is not valid YAML: ${message}.${hint}`);
+  }
+  if (!isRecord(parsed)) {
+    throw fail("SKILL.md frontmatter must be a YAML mapping.");
+  }
+  return {
+    ...typeof parsed.name === "string" ? { name: parsed.name.trim() } : {},
+    ...typeof parsed.description === "string" ? { description: parsed.description.trim() } : {}
+  };
+}
+function createFilesBudget(directory) {
+  let total = 0;
+  return (size) => {
+    total += size;
+    if (total > MAX_AGENT_FILES_BYTES) {
+      throw new RuntimeError2(`[Sixb] The files under ${directory} exceed ${MAX_AGENT_FILES_BYTES / 1024 / 1024} MB. ` + "Every agent sandbox receives them: keep large assets out of the project, or have a " + "script fetch them when needed.");
+    }
+  };
+}
+function isMarkdown(path) {
+  return path.toLowerCase().endsWith(".md");
+}
+function decodeUtf8(bytes) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toPosixRelative(from, to) {
+  return relative(from, to).split(sep).join("/");
+}
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function skillError(projectRoot, skillDir, message) {
+  return new RuntimeError2(`[Sixb] Agent Skill '${toPosixRelative(projectRoot, skillDir)}' is invalid: ${message}`);
+}
+function instructionsError(message) {
+  return new RuntimeError2(`[Sixb] ${PROJECT_INSTRUCTIONS_FILE} ${message}`);
+}
 
 // src/rules/errors.ts
 class RuleError extends Error {
@@ -58,7 +312,7 @@ class RuleValidationError2 extends RuleError {
 }
 
 // src/rules/validation.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function assertNonEmptyString(value, field, createError) {
@@ -70,14 +324,14 @@ function assertRulePredicateShape(value, createError = (message) => new RuleVali
   assertPredicateShape(value, { subject: "Rule", createError });
 }
 function assertRuleDefinition(value, createError = (message) => new RuleValidationError2(message)) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     throw createError("Rule definition must be an object.");
   }
   if (value.kind !== "rule") {
     throw createError("Rule definition kind must be 'rule'.");
   }
   assertNonEmptyString(value.id, "Rule id", createError);
-  if (!isRecord(value.subject) || value.subject.kind !== "object") {
+  if (!isRecord2(value.subject) || value.subject.kind !== "object") {
     throw createError(`Rule '${value.id}' subject must be an object subject.`);
   }
   assertNonEmptyString(value.subject.objectTypeId, `Rule '${value.id}' subject objectTypeId`, createError);
@@ -219,24 +473,43 @@ function invalid(message) {
   return new ShareDefinitionError2(`[Sixb] ${message}`);
 }
 // src/bootstrap/discovery.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { readdir as readdir2 } from "fs/promises";
+import { join as join2, relative as relative2, resolve, sep as sep2 } from "path";
+import { pathToFileURL } from "url";
 var moduleExtensions = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
-async function discoverOntologySources2(projectRoot) {
-  const exportedCandidates = await loadFamilyExports(projectRoot, "ontology", ["ontology"]);
+async function discoverOntologySources(projectRoot) {
+  const loadedModules = await loadFamilyModules(projectRoot, "ontology", ["ontology"]);
   const ontologyDocuments = [];
   const objectTypes = [];
   const valueTypes = [];
-  for (const candidate of exportedCandidates) {
-    if (isOntologyDocumentInput(candidate)) {
-      ontologyDocuments.push(candidate);
-      continue;
-    }
-    if (isObjectTypeWithPropertyTokens(candidate)) {
-      objectTypes.push(candidate);
-      continue;
-    }
-    if (isValueType(candidate)) {
-      valueTypes.push(candidate);
+  const modules = [];
+  const seen = new Set;
+  for (const loaded of loadedModules) {
+    const objectTypeIds = [];
+    for (const candidate of loaded.exports) {
+      const first = !seen.has(candidate);
+      seen.add(candidate);
+      if (isOntologyDocumentInput(candidate)) {
+        objectTypeIds.push(...candidate.objectTypes.map((objectType) => objectType.id));
+        if (first)
+          ontologyDocuments.push(candidate);
+        continue;
+      }
+      if (isObjectTypeWithPropertyTokens(candidate)) {
+        objectTypeIds.push(candidate.id);
+        if (first)
+          objectTypes.push(candidate);
+        continue;
+      }
+      if (isValueType(candidate) && first) {
+        valueTypes.push(candidate);
+      }
     }
+    modules.push({
+      path: toPosix(relative2("ontology", loaded.path)),
+      objectTypeIds: [...new Set(objectTypeIds)]
+    });
   }
   const discoveredSources = [...ontologyDocuments, ...objectTypes];
   if (valueTypes.length > 0) {
@@ -247,7 +520,7 @@ async function discoverOntologySources2(projectRoot) {
       valueTypes
     });
   }
-  return discoveredSources;
+  return { sources: discoveredSources, modules };
 }
 var bundledProject = new AsyncLocalStorage;
 function withProjectModules2(projectRoot, modules, run) {
@@ -283,6 +556,11 @@ var definitionDiscoveryRegistry = {
     kind: "workflow",
     isDefinition: isWorkflowDefinition2
   },
+  markings: {
+    directory: ["security", "markings"],
+    kind: "marking",
+    isDefinition: isMarkingDefinition
+  },
   groups: {
     directory: ["security", "groups"],
     kind: "group",
@@ -315,30 +593,33 @@ async function discoverProjectDefinitions2(projectRoot) {
   return Object.fromEntries(entries);
 }
 async function discoverDefinitionFamily(projectRoot, family) {
-  const exportedCandidates = await loadFamilyExports(projectRoot, family.kind, family.directory);
-  return exportedCandidates.filter(family.isDefinition);
+  const loadedModules = await loadFamilyModules(projectRoot, family.kind, family.directory);
+  const exportedCandidates = new Set(loadedModules.flatMap((loaded) => loaded.exports));
+  return [...exportedCandidates].filter(family.isDefinition);
+}
+function listOntologyModuleFiles(projectRoot) {
+  return listModuleFiles(join2(projectRoot, "ontology"), isOntologyScriptsDirectory);
 }
 async function listFamilyModules(projectRoot, kind, directory) {
-  const paths = await listModuleFiles(join(projectRoot, ...directory));
-  return paths.map((path) => ({ kind, path: relative(projectRoot, path) }));
+  const paths = kind === "ontology" ? await listOntologyModuleFiles(projectRoot) : await listModuleFiles(join2(projectRoot, ...directory));
+  return paths.map((path) => ({ kind, path: relative2(projectRoot, path) }));
 }
-async function loadFamilyExports(projectRoot, kind, directory) {
+async function loadFamilyModules(projectRoot, kind, directory) {
   const project = bundledProject.getStore();
   if (project) {
     if (resolve(projectRoot) !== project.projectRoot) {
       throw new RuntimeError2(`Built project discovery is scoped to '${project.projectRoot}', not '${projectRoot}'. ` + "Run the built entry from the project root and use that root in createSixb().");
     }
-    return loadModuleExports(project.modules.filter((module) => module.kind === kind));
+    return loadModules(project.modules.filter((module) => module.kind === kind));
   }
   const modules = await listFamilyModules(projectRoot, kind, directory);
-  return loadModuleExports(modules.map((module) => ({
+  return loadModules(modules.map((module) => ({
     ...module,
     load: () => import(pathToFileURL(resolve(projectRoot, module.path)).href)
   })));
 }
-async function loadModuleExports(modules) {
-  const exportedCandidates = [];
-  const seen = new Set;
+async function loadModules(modules) {
+  const loaded = [];
   for (const module of modules) {
     let moduleNamespace;
     try {
@@ -347,11 +628,14 @@ async function loadModuleExports(modules) {
       const reason = error instanceof Error ? error.message : String(error);
       throw new RuntimeError2(`Failed to load ${module.kind} module '${module.path}': ${reason}`);
     }
+    const exportedCandidates = [];
+    const seen = new Set;
     for (const exportedValue of Object.values(moduleNamespace)) {
       collectExportedCandidates(exportedValue, exportedCandidates, seen);
     }
+    loaded.push({ path: module.path, exports: exportedCandidates });
   }
-  return exportedCandidates;
+  return loaded;
 }
 function collectExportedCandidates(value, target, seen) {
   if (Array.isArray(value)) {
@@ -371,10 +655,10 @@ function collectExportedCandidates(value, target, seen) {
   }
   target.push(value);
 }
-async function listModuleFiles(dir) {
+async function listModuleFiles(dir, skipDirectory = () => false) {
   let entries;
   try {
-    entries = await readdir(dir, { withFileTypes: true });
+    entries = await readdir2(dir, { withFileTypes: true });
   } catch (error) {
     if (isNotFoundError(error)) {
       return [];
@@ -384,9 +668,11 @@ async function listModuleFiles(dir) {
   const files = [];
   const sortedEntries = [...entries].sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of sortedEntries) {
-    const fullPath = join(dir, entry.name);
+    const fullPath = join2(dir, entry.name);
     if (entry.isDirectory()) {
-      files.push(...await listModuleFiles(fullPath));
+      if (!skipDirectory(entry.name)) {
+        files.push(...await listModuleFiles(fullPath, skipDirectory));
+      }
       continue;
     }
     if (!entry.isFile()) {
@@ -415,262 +701,31 @@ function hasSupportedModuleExtension(fileName) {
   }
   return false;
 }
-function isRecord2(value) {
+function toPosix(path) {
+  return path.split(sep2).join("/");
+}
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isOntologyDocumentInput(value) {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     return false;
   }
   return typeof value.id === "string" && typeof value.version === "string" && Array.isArray(value.objectTypes);
 }
 function isObjectTypeWithPropertyTokens(value) {
-  if (!isRecord2(value)) {
-    return false;
-  }
-  return typeof value.id === "string" && Array.isArray(value.properties) && Array.isArray(value.links) && isRecord2(value.p);
-}
-function isValueType(value) {
-  if (!isRecord2(value)) {
-    return false;
-  }
-  return typeof value.id === "string" && typeof value.name === "string" && "schema" in value && !Array.isArray(value.properties) && !Array.isArray(value.objectTypes);
-}
-// src/bootstrap/ontology-type-manifest.ts
-import { access, mkdir, readdir as readdir2, readFile, writeFile } from "fs/promises";
-import { dirname, extname, join as join2, relative as relative2, resolve as resolve2, sep } from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
-var moduleExtensions2 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
-async function discoverOntologyTypeManifest2(projectRoot) {
-  const resolvedProjectRoot = resolve2(projectRoot);
-  const ontologyDir = join2(resolvedProjectRoot, "ontology");
-  const modulePaths = await listModuleFiles2(ontologyDir);
-  const entries = new Map;
-  const valueTypeEntries = new Map;
-  const seen = new Set;
-  for (const modulePath of modulePaths) {
-    const moduleSpecifier = toGeneratedModuleSpecifier({
-      fromDir: join2(resolvedProjectRoot, ".sixb", "types"),
-      modulePath
-    });
-    const moduleNamespace = await loadOntologyModule({
-      modulePath,
-      projectRoot: resolvedProjectRoot
-    });
-    for (const [exportName, exportedValue] of Object.entries(moduleNamespace)) {
-      collectManifestEntries({
-        exportedValue,
-        exportName,
-        modulePath,
-        moduleSpecifier,
-        entries,
-        valueTypeEntries,
-        seen
-      });
-    }
-  }
-  return {
-    entries: [...entries.values()].sort((a, b) => a.objectTypeId.localeCompare(b.objectTypeId)),
-    valueTypeEntries: [...valueTypeEntries.values()].sort((a, b) => a.valueTypeId.localeCompare(b.valueTypeId)),
-    moduleCount: modulePaths.length
-  };
-}
-async function generateOntologyTypeManifest2(options) {
-  const projectRoot = resolve2(options.projectRoot);
-  const outFile = resolve2(projectRoot, options.outFile ?? join2(".sixb", "types", "ontology.d.ts"));
-  const discovery = await discoverOntologyTypeManifest2(projectRoot);
-  if (discovery.moduleCount === 0) {
-    try {
-      await access(outFile);
-    } catch (error) {
-      if (!isNotFoundError2(error))
-        throw error;
-      return {
-        ...discovery,
-        path: outFile,
-        written: false,
-        skipped: true
-      };
-    }
-  }
-  const content = renderOntologyTypeManifest(discovery);
-  await mkdir(dirname(outFile), { recursive: true });
-  const written = await writeFileIfChanged(outFile, content);
-  return {
-    ...discovery,
-    path: outFile,
-    written,
-    skipped: false
-  };
-}
-function collectManifestEntries(input) {
-  const exported = `(typeof import(${JSON.stringify(input.moduleSpecifier)})[${JSON.stringify(input.exportName)}])`;
-  const add = (value, typeExpression) => {
-    if (isObjectTypeWithPropertyTokens2(value)) {
-      addManifestEntry({
-        kind: "object type",
-        definition: value,
-        entry: {
-          objectTypeId: value.id,
-          modulePath: input.modulePath,
-          exportName: input.exportName,
-          typeExpression: typeExpression(value.id)
-        },
-        idOf: (entry) => entry.objectTypeId,
-        entries: input.entries,
-        seen: input.seen
-      });
-    } else if (isValueType2(value)) {
-      addManifestEntry({
-        kind: "value type",
-        definition: value,
-        entry: {
-          valueTypeId: value.id,
-          modulePath: input.modulePath,
-          exportName: input.exportName,
-          typeExpression: typeExpression(value.id)
-        },
-        idOf: (entry) => entry.valueTypeId,
-        entries: input.valueTypeEntries,
-        seen: input.seen
-      });
-    }
-  };
-  if (isOntologyDocumentInput2(input.exportedValue)) {
-    for (const objectType of input.exportedValue.objectTypes) {
-      add(objectType, (id) => `Extract<${exported}["objectTypes"][number], { id: ${JSON.stringify(id)} }>`);
-    }
-    for (const valueType of input.exportedValue.valueTypes ?? []) {
-      add(valueType, (id) => `Extract<${exported}["valueTypes"][number], { id: ${JSON.stringify(id)} }>`);
-    }
-    return;
-  }
-  if (Array.isArray(input.exportedValue)) {
-    for (const item of input.exportedValue) {
-      add(item, (id) => `Extract<${exported}[number], { id: ${JSON.stringify(id)} }>`);
-    }
-    return;
-  }
-  add(input.exportedValue, () => `typeof import(${JSON.stringify(input.moduleSpecifier)})[${JSON.stringify(input.exportName)}]`);
-}
-function addManifestEntry(input) {
-  if (input.seen.has(input.definition)) {
-    return;
-  }
-  input.seen.add(input.definition);
-  const id = input.idOf(input.entry);
-  const existing = input.entries.get(id);
-  if (!existing) {
-    input.entries.set(id, input.entry);
-    return;
-  }
-  throw new RuntimeError2(`[Sixb] Duplicate ontology ${input.kind} id "${id}" while generating `.concat(`the type manifest: ${relative2(process.cwd(), existing.modulePath)} and `, `${relative2(process.cwd(), input.entry.modulePath)}.`));
-}
-function renderOntologyTypeManifest(discovery) {
-  const lines = [
-    "// This file is auto-generated by Sixb.",
-    "// Do not edit this file directly.",
-    "",
-    'declare module "@sixb/core/ontology" {',
-    "  interface SixbObjectTypeMap {"
-  ];
-  for (const entry of discovery.entries) {
-    lines.push(`    ${JSON.stringify(entry.objectTypeId)}: ${entry.typeExpression}`);
-  }
-  lines.push("  }", "  interface SixbValueTypeMap {");
-  for (const entry of discovery.valueTypeEntries) {
-    lines.push(`    ${JSON.stringify(entry.valueTypeId)}: ${entry.typeExpression}`);
-  }
-  lines.push("  }", "}", "", "export {}", "");
-  return lines.join(`
-`);
-}
-async function writeFileIfChanged(path, content) {
-  try {
-    const existing = await readFile(path, "utf-8");
-    if (existing === content)
-      return false;
-  } catch (error) {
-    if (!isNotFoundError2(error))
-      throw error;
-  }
-  await writeFile(path, content, "utf-8");
-  return true;
-}
-async function loadOntologyModule(input) {
-  try {
-    return await import(pathToFileURL2(input.modulePath).href);
-  } catch (error) {
-    const relPath = relative2(input.projectRoot, input.modulePath);
-    const reason = error instanceof Error ? error.message : String(error);
-    throw new RuntimeError2(`Failed to load ontology module '${relPath}': ${reason}`);
-  }
-}
-async function listModuleFiles2(dir) {
-  let entries;
-  try {
-    entries = await readdir2(dir, { withFileTypes: true });
-  } catch (error) {
-    if (isNotFoundError2(error)) {
-      return [];
-    }
-    throw error;
-  }
-  const files = [];
-  const sortedEntries = [...entries].sort((a, b) => a.name.localeCompare(b.name));
-  for (const entry of sortedEntries) {
-    const fullPath = join2(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...await listModuleFiles2(fullPath));
-      continue;
-    }
-    if (!entry.isFile() || !hasSupportedModuleExtension2(entry.name)) {
-      continue;
-    }
-    files.push(fullPath);
-  }
-  return files;
-}
-function toGeneratedModuleSpecifier(input) {
-  const withoutExtension = stripSupportedModuleExtension(input.modulePath);
-  const relativePath = relative2(input.fromDir, withoutExtension).split(sep).join("/");
-  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-}
-function stripSupportedModuleExtension(path) {
-  const extension = extname(path);
-  return moduleExtensions2.has(extension) ? path.slice(0, -extension.length) : path;
-}
-function hasSupportedModuleExtension2(fileName) {
-  return moduleExtensions2.has(extname(fileName).toLowerCase());
-}
-function isNotFoundError2(error) {
-  if (!(error instanceof Error)) {
-    return false;
-  }
-  const code = error.code;
-  return code === "ENOENT" || code === "ENOTDIR";
-}
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isObjectTypeWithPropertyTokens2(value) {
   if (!isRecord3(value)) {
     return false;
   }
   return typeof value.id === "string" && Array.isArray(value.properties) && Array.isArray(value.links) && isRecord3(value.p);
 }
-function isValueType2(value) {
+function isValueType(value) {
   if (!isRecord3(value)) {
     return false;
   }
   return typeof value.id === "string" && typeof value.name === "string" && "schema" in value && !Array.isArray(value.properties) && !Array.isArray(value.objectTypes);
 }
-function isOntologyDocumentInput2(value) {
-  if (!isRecord3(value)) {
-    return false;
-  }
-  return typeof value.id === "string" && typeof value.version === "string" && Array.isArray(value.objectTypes);
-}
-export { RuleValidationError2, isRuleDefinition2, validateRulesAtStartup, defineRule2, validateSharesAtStartup, discoverOntologySources2, withProjectModules2, listProjectModules2, discoverProjectDefinitions2, discoverOntologyTypeManifest2, generateOntologyTypeManifest2 };
 
-//# debugId=0C3D7CE71EFB366064756E2164756E21
+export { isAgentContextPath2, discoverOntologyFiles, discoverAgentSkills, discoverProjectInstructions, RuleValidationError2, isRuleDefinition2, validateRulesAtStartup, defineRule2, validateSharesAtStartup, discoverOntologySources, withProjectModules2, listProjectModules2, discoverProjectDefinitions2, listOntologyModuleFiles };
+
+//# debugId=C7F7E1BCFC5009D864756E2164756E21