@lucern/pack-host 0.3.0-alpha.9 → 1.0.1

package/dist/domain-pack/authoring.js

@@ -60,1122 +60,1186 @@ function defineDomainPack(input) {
   };
 }
 
-// src/domain-pack/validation.ts
-function issue(code, message, path, severity = "error") {
-  return { code, severity, message, path };
+// src/domain-pack/authoring.core.ts
+var DOMAIN_PACK_MANIFEST_KIND = "lucern-domain-pack-manifest";
+var CURRENT_MANIFEST_VERSION = "1.0.0";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
 }
-var KEBAB_CASE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
-var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
-var SHAPING_QUESTION_TYPES = /* @__PURE__ */ new Set([
-  "validation",
-  "falsification",
-  "assumption_probe",
-  "counterfactual",
-  "scope",
-  "comparison",
-  "mechanism",
-  "general"
-]);
-var RUNTIME_TARGETS = /* @__PURE__ */ new Set(["claude-code", "codex", "hybrid", "portable"]);
-var ONTOLOGY_PROVISION_MODES = /* @__PURE__ */ new Set(["bind", "seed", "extend"]);
-function validateStringArray(values, path, label) {
+function dedupeStrings2(values) {
   if (!values) {
-    return [];
+    return void 0;
   }
-  return values.flatMap((value, index) => {
-    if (!value?.trim()) {
-      return [
-        issue(
-          "INVALID_SHAPING_CONDITION",
-          `${label} must not contain empty strings`,
-          `${path}[${index}]`
-        )
-      ];
-    }
-    return [];
-  });
+  return Array.from(
+    new Set(values.map((value) => value.trim()).filter((value) => value.length))
+  );
 }
-function validateRuntimeTargets(values, path) {
-  const issues = validateStringArray(values, path, "runtimeTargets");
-  for (const [index, value] of (values || []).entries()) {
-    if (!RUNTIME_TARGETS.has(value)) {
-      issues.push(
-        issue(
-          "INVALID_RUNTIME_TARGET",
-          `Unsupported runtime target "${value}"`,
-          `${path}[${index}]`
-        )
-      );
-    }
-  }
-  return issues;
+function normalizeRuntimeTargets2(values) {
+  return values ? dedupeStrings2(values) : void 0;
 }
-function validatePromptBinding(prompt, index) {
-  const path = `operatingSystem.prompts[${index}]`;
-  const issues = [];
-  if (!prompt.promptId?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_PROMPT_ID",
-        "prompt binding requires promptId",
-        `${path}.promptId`
-      )
-    );
+function normalizeFrameworks(frameworks) {
+  if (!frameworks) {
+    return void 0;
   }
-  if (!prompt.ref?.trim()) {
-    issues.push(
-      issue("MISSING_PROMPT_REF", "prompt binding requires ref", `${path}.ref`)
-    );
+  return frameworks.map((framework) => ({
+    ...framework,
+    frameworkId: framework.frameworkId.trim(),
+    version: framework.version.trim(),
+    versionConstraint: framework.versionConstraint?.trim(),
+    runtimeTargets: normalizeRuntimeTargets2(framework.runtimeTargets)
+  }));
+}
+function normalizeSchemaExtensions(extensions) {
+  if (!extensions) {
+    return void 0;
   }
-  issues.push(
-    ...validateRuntimeTargets(prompt.runtimeTargets, `${path}.runtimeTargets`)
-  );
-  return issues;
+  return extensions.map((extension) => ({
+    ...extension,
+    extensionId: extension.extensionId.trim(),
+    target: extension.target,
+    description: extension.description.trim(),
+    version: extension.version.trim(),
+    extends: extension.extends?.trim()
+  }));
 }
-function validateToolBinding(tool, index) {
-  const path = `operatingSystem.tools[${index}]`;
-  const issues = [];
-  if (!tool.toolId?.trim()) {
-    issues.push(
-      issue("MISSING_TOOL_ID", "tool binding requires toolId", `${path}.toolId`)
-    );
+function normalizeOntologyExtensions(extensions) {
+  if (!extensions) {
+    return void 0;
   }
-  if (!tool.entrypoint?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_TOOL_ENTRYPOINT",
-        "tool binding requires entrypoint",
-        `${path}.entrypoint`
-      )
-    );
+  return extensions.map((extension) => ({
+    ...extension,
+    extensionId: extension.extensionId.trim(),
+    ontologyId: extension.ontologyId.trim(),
+    baseVersionConstraint: extension.baseVersionConstraint.trim(),
+    entityTypes: extension.entityTypes?.map((entityType) => ({
+      ...entityType,
+      value: entityType.value.trim(),
+      label: entityType.label.trim(),
+      description: entityType.description?.trim(),
+      subtypes: dedupeStrings2(entityType.subtypes)
+    })),
+    edgeTypes: extension.edgeTypes?.map((edgeType) => ({
+      ...edgeType,
+      value: edgeType.value.trim(),
+      label: edgeType.label.trim(),
+      description: edgeType.description?.trim(),
+      sourceTypes: dedupeStrings2(edgeType.sourceTypes),
+      targetTypes: dedupeStrings2(edgeType.targetTypes)
+    }))
+  }));
+}
+function normalizeLineage(lineage) {
+  if (!lineage) {
+    return { mode: "root" };
   }
-  issues.push(
-    ...validateRuntimeTargets(tool.runtimeTargets, `${path}.runtimeTargets`)
-  );
-  return issues;
+  return {
+    mode: lineage.mode,
+    parentPackId: lineage.parentPackId?.trim(),
+    parentVersion: lineage.parentVersion?.trim(),
+    parentManifestDigest: lineage.parentManifestDigest?.trim(),
+    supersedesPackId: lineage.supersedesPackId?.trim(),
+    notes: lineage.notes?.trim()
+  };
 }
-function validateSetupAsset(asset, index) {
-  const path = `operatingSystem.setupAssets[${index}]`;
-  const issues = [];
-  if (!asset.assetId?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_SETUP_ASSET_ID",
-        "setup asset requires assetId",
-        `${path}.assetId`
-      )
-    );
+function normalizeMetadata(metadata) {
+  if (!metadata) {
+    return void 0;
   }
-  if (!asset.path?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_SETUP_ASSET_PATH",
-        "setup asset requires path",
-        `${path}.path`
-      )
-    );
+  return {
+    description: metadata.description?.trim(),
+    owner: metadata.owner?.trim(),
+    tags: dedupeStrings2(metadata.tags)
+  };
+}
+function toDomainPack(pack) {
+  return defineDomainPack(pack);
+}
+function defineDomainPackAuthoringManifest(input) {
+  return {
+    kind: input.kind ?? DOMAIN_PACK_MANIFEST_KIND,
+    manifestVersion: input.manifestVersion?.trim() || CURRENT_MANIFEST_VERSION,
+    pack: toDomainPack(input.pack),
+    frameworks: normalizeFrameworks(input.frameworks),
+    schemaExtensions: normalizeSchemaExtensions(input.schemaExtensions),
+    ontologyExtensions: normalizeOntologyExtensions(input.ontologyExtensions),
+    lineage: normalizeLineage(input.lineage),
+    metadata: normalizeMetadata(input.metadata)
+  };
+}
+function countManifestArtifacts(manifest) {
+  if (!manifest) {
+    return {
+      topicRoots: 0,
+      workflows: 0,
+      gates: 0,
+      artifacts: 0,
+      roles: 0,
+      prompts: 0,
+      tools: 0,
+      setupAssets: 0,
+      installProfiles: 0,
+      frameworks: 0,
+      schemaExtensions: 0,
+      ontologyExtensions: 0
+    };
   }
-  issues.push(
-    ...validateRuntimeTargets(asset.runtimeTargets, `${path}.runtimeTargets`)
-  );
-  return issues;
+  return {
+    topicRoots: manifest.pack.topicRoots.length,
+    workflows: manifest.pack.workflows.length,
+    gates: manifest.pack.gates.length,
+    artifacts: manifest.pack.artifacts.length,
+    roles: manifest.pack.roles.length,
+    prompts: manifest.pack.operatingSystem?.prompts?.length ?? 0,
+    tools: manifest.pack.operatingSystem?.tools?.length ?? 0,
+    setupAssets: manifest.pack.operatingSystem?.setupAssets?.length ?? 0,
+    installProfiles: manifest.pack.operatingSystem?.installProfiles?.length ?? 0,
+    frameworks: manifest.frameworks?.length ?? 0,
+    schemaExtensions: manifest.schemaExtensions?.length ?? 0,
+    ontologyExtensions: manifest.ontologyExtensions?.length ?? 0
+  };
 }
-function validateQuestionTemplate(template, index) {
-  const path = `inquiryShaping.questionTemplates[${index}]`;
-  const issues = [];
-  if (!template.templateId?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_SHAPING_TEMPLATE_ID",
-        "question template requires templateId",
-        `${path}.templateId`
-      )
-    );
+function sortJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJsonValue);
   }
-  if (!template.template?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_SHAPING_TEMPLATE",
-        "question template requires template text",
-        `${path}.template`
-      )
+  if (isPlainObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => [key, sortJsonValue(entryValue)])
     );
   }
-  if (!SHAPING_QUESTION_TYPES.has(template.questionType)) {
-    issues.push(
-      issue(
-        "INVALID_SHAPING_QUESTION_TYPE",
-        `Unsupported questionType "${template.questionType}"`,
-        `${path}.questionType`
-      )
-    );
+  return value;
+}
+function toYamlScalar(value) {
+  if (value === null) {
+    return "null";
   }
-  issues.push(
-    ...validateStringArray(
-      template.whenObjectiveIncludes,
-      `${path}.whenObjectiveIncludes`,
-      "whenObjectiveIncludes"
-    )
-  );
-  return issues;
-}
-function validateTaskTemplate(template, index) {
-  const path = `inquiryShaping.taskTemplates[${index}]`;
-  const issues = [];
-  if (!template.templateId?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_TASK_GENERATOR_ID",
-        "task template requires templateId",
-        `${path}.templateId`
-      )
-    );
+  if (typeof value === "boolean" || typeof value === "number") {
+    return String(value);
   }
-  if (!template.title?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_TASK_GENERATOR_TITLE",
-        "task template requires title",
-        `${path}.title`
-      )
-    );
+  return JSON.stringify(String(value));
+}
+function renderYaml(value, indent = 0) {
+  const prefix = " ".repeat(indent);
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return [`${prefix}[]`];
+    }
+    return value.flatMap((entry) => {
+      if (Array.isArray(entry) || isPlainObject(entry)) {
+        return [`${prefix}-`, ...renderYaml(entry, indent + 2)];
+      }
+      return [`${prefix}- ${toYamlScalar(entry)}`];
+    });
   }
-  issues.push(
-    ...validateStringArray(
-      template.whenObjectiveIncludes,
-      `${path}.whenObjectiveIncludes`,
-      "whenObjectiveIncludes"
-    )
-  );
-  issues.push(
-    ...validateStringArray(
-      template.whenQuestionTypes,
-      `${path}.whenQuestionTypes`,
-      "whenQuestionTypes"
-    )
-  );
-  for (const [questionTypeIndex, questionType] of (template.whenQuestionTypes || []).entries()) {
-    if (!SHAPING_QUESTION_TYPES.has(questionType)) {
-      issues.push(
-        issue(
-          "INVALID_TASK_GENERATOR_QUESTION_TYPE",
-          `Unsupported whenQuestionTypes value "${questionType}"`,
-          `${path}.whenQuestionTypes[${questionTypeIndex}]`
-        )
-      );
+  if (isPlainObject(value)) {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return [`${prefix}{}`];
     }
+    return entries.flatMap(([key, entryValue]) => {
+      if (entryValue === void 0) {
+        return [];
+      }
+      if (Array.isArray(entryValue)) {
+        if (entryValue.length === 0) {
+          return [`${prefix}${key}: []`];
+        }
+        return [`${prefix}${key}:`, ...renderYaml(entryValue, indent + 2)];
+      }
+      if (isPlainObject(entryValue)) {
+        if (Object.keys(entryValue).length === 0) {
+          return [`${prefix}${key}: {}`];
+        }
+        return [`${prefix}${key}:`, ...renderYaml(entryValue, indent + 2)];
+      }
+      return [`${prefix}${key}: ${toYamlScalar(entryValue)}`];
+    });
   }
-  return issues;
+  return [`${prefix}${toYamlScalar(value)}`];
 }
-function validateFrameworkHint(hint, index) {
-  const path = `inquiryShaping.frameworkHints[${index}]`;
-  const issues = [];
-  if (!hint.frameworkName?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_FRAMEWORK_HOOK_NAME",
-        "framework hint requires frameworkName",
-        `${path}.frameworkName`
-      )
-    );
+function countIndent(line) {
+  return line.length - line.trimStart().length;
+}
+function parseYamlScalar(raw) {
+  const value = raw.trim();
+  if (value === "null") {
+    return null;
   }
-  if (hint.boost != null && (!Number.isFinite(hint.boost) || hint.boost < 0)) {
-    issues.push(
-      issue(
-        "INVALID_FRAMEWORK_HOOK_BOOST",
-        "framework hint boost must be a non-negative number",
-        `${path}.boost`
-      )
-    );
+  if (value === "true") {
+    return true;
   }
-  issues.push(
-    ...validateStringArray(
-      hint.whenObjectiveIncludes,
-      `${path}.whenObjectiveIncludes`,
-      "whenObjectiveIncludes"
-    )
-  );
-  issues.push(
-    ...validateStringArray(
-      hint.whenQuestionTypes,
-      `${path}.whenQuestionTypes`,
-      "whenQuestionTypes"
-    )
-  );
-  for (const [questionTypeIndex, questionType] of (hint.whenQuestionTypes || []).entries()) {
-    if (!SHAPING_QUESTION_TYPES.has(questionType)) {
-      issues.push(
-        issue(
-          "INVALID_FRAMEWORK_HOOK_QUESTION_TYPE",
-          `Unsupported whenQuestionTypes value "${questionType}"`,
-          `${path}.whenQuestionTypes[${questionTypeIndex}]`
-        )
-      );
-    }
+  if (value === "false") {
+    return false;
   }
-  return issues;
-}
-function validateTopicTemplate(template, index, knownTopicSlugs) {
-  const path = `operatingSystem.topicTemplates[${index}]`;
-  const issues = [];
-  if (!template.slug?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_TOPIC_TEMPLATE_SLUG",
-        "topic template requires slug",
-        `${path}.slug`
-      )
-    );
-  } else if (!KEBAB_CASE.test(template.slug)) {
-    issues.push(
-      issue(
-        "INVALID_TOPIC_TEMPLATE_SLUG",
-        `topic template slug "${template.slug}" must be kebab-case`,
-        `${path}.slug`
-      )
-    );
+  if (/^-?\d+(?:\.\d+)?$/.test(value)) {
+    return Number(value);
   }
-  if (!template.name?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_TOPIC_TEMPLATE_NAME",
-        "topic template requires name",
-        `${path}.name`
-      )
-    );
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    if (value.startsWith("'")) {
+      return value.slice(1, -1).replace(/''/g, "'");
+    }
+    return JSON.parse(value);
   }
-  if (!template.description?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_TOPIC_TEMPLATE_DESCRIPTION",
-        "topic template requires description",
-        `${path}.description`
-      )
-    );
+  if (value === "[]") {
+    return [];
   }
-  if (template.parentSlug && !knownTopicSlugs.has(template.parentSlug)) {
-    issues.push(
-      issue(
-        "UNKNOWN_TOPIC_PARENT",
-        `topic template references unknown parent "${template.parentSlug}"`,
-        `${path}.parentSlug`
-      )
-    );
+  if (value === "{}") {
+    return {};
   }
-  return issues;
+  return value;
 }
-function validateInstallProfile(profile, index, knownPromptIds, knownToolIds, knownAssetIds, knownTopicSlugs) {
-  const path = `operatingSystem.installProfiles[${index}]`;
-  const issues = [];
-  if (!profile.profileId?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_INSTALL_PROFILE_ID",
-        "install profile requires profileId",
-        `${path}.profileId`
-      )
-    );
+function splitYamlKeyValue(trimmed) {
+  const separatorIndex = trimmed.indexOf(":");
+  if (separatorIndex === -1) {
+    throw new Error(`Invalid YAML mapping entry: ${trimmed}`);
   }
-  if (!profile.name?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_INSTALL_PROFILE_NAME",
-        "install profile requires name",
-        `${path}.name`
-      )
-    );
+  const key = trimmed.slice(0, separatorIndex).trim();
+  const value = trimmed.slice(separatorIndex + 1).trim();
+  return { key, value: value.length ? value : null };
+}
+function parseYamlDocument(text) {
+  const rawLines = text.replace(/\r\n/g, "\n").split("\n").map((line) => line.replace(/\t/g, "  "));
+  const lines = rawLines.filter((line) => {
+    const trimmed = line.trim();
+    return trimmed.length > 0 && trimmed !== "---" && trimmed !== "...";
+  });
+  let index = 0;
+  function parseBlock(indent) {
+    if (index >= lines.length) {
+      return {};
+    }
+    const currentLine = lines[index];
+    const currentIndent = countIndent(currentLine);
+    if (currentIndent < indent) {
+      return {};
+    }
+    if (currentLine.trimStart().startsWith("-")) {
+      return parseArray(indent);
+    }
+    return parseObject(indent);
   }
-  if (!profile.description?.trim()) {
-    issues.push(
-      issue(
-        "MISSING_INSTALL_PROFILE_DESCRIPTION",
-        "install profile requires description",
-        `${path}.description`
-      )
-    );
-  }
-  if (!RUNTIME_TARGETS.has(profile.runtimeTarget)) {
-    issues.push(
-      issue(
-        "INVALID_RUNTIME_TARGET",
-        `Unsupported runtime target "${profile.runtimeTarget}"`,
-        `${path}.runtimeTarget`
-      )
-    );
-  }
-  for (const [promptIndex, promptId] of profile.promptIds.entries()) {
-    if (!knownPromptIds.has(promptId)) {
-      issues.push(
-        issue(
-          "UNKNOWN_PROMPT_REF",
-          `install profile references unknown prompt "${promptId}"`,
-          `${path}.promptIds[${promptIndex}]`
-        )
-      );
+  function parseArray(indent) {
+    const items = [];
+    while (index < lines.length) {
+      const line = lines[index];
+      const currentIndent = countIndent(line);
+      if (currentIndent < indent) {
+        break;
+      }
+      if (currentIndent !== indent) {
+        throw new Error(`Invalid YAML indentation near: ${line.trim()}`);
+      }
+      const trimmed = line.trimStart();
+      if (!trimmed.startsWith("-")) {
+        break;
+      }
+      const rest = trimmed.slice(1).trimStart();
+      index += 1;
+      if (!rest.length) {
+        items.push(parseBlock(indent + 2));
+        continue;
+      }
+      items.push(parseYamlScalar(rest));
     }
+    return items;
   }
-  for (const [toolIndex, toolId] of profile.toolIds.entries()) {
-    if (!knownToolIds.has(toolId)) {
-      issues.push(
-        issue(
-          "UNKNOWN_TOOL_REF",
-          `install profile references unknown tool "${toolId}"`,
-          `${path}.toolIds[${toolIndex}]`
-        )
-      );
+  function parseObject(indent) {
+    const objectValue = {};
+    while (index < lines.length) {
+      const line = lines[index];
+      const currentIndent = countIndent(line);
+      if (currentIndent < indent) {
+        break;
+      }
+      if (currentIndent !== indent) {
+        throw new Error(`Invalid YAML indentation near: ${line.trim()}`);
+      }
+      const trimmed = line.trim();
+      if (trimmed.startsWith("-")) {
+        break;
+      }
+      const { key, value } = splitYamlKeyValue(trimmed);
+      index += 1;
+      objectValue[key] = value === null ? parseBlock(indent + 2) : parseYamlScalar(value);
     }
+    return objectValue;
   }
-  for (const [assetIndex, assetId] of profile.assetIds.entries()) {
-    if (!knownAssetIds.has(assetId)) {
-      issues.push(
+  return parseBlock(0);
+}
+function detectDomainPackManifestFormat(source, explicitFormat) {
+  if (explicitFormat) {
+    return explicitFormat;
+  }
+  const trimmed = source.trim();
+  if (trimmed.startsWith("{")) {
+    return "json";
+  }
+  return "yaml";
+}
+function serializeDomainPackAuthoringManifest(manifest, format = "json") {
+  const canonicalValue = sortJsonValue(manifest);
+  if (format === "json") {
+    return `${JSON.stringify(canonicalValue, null, 2)}
+`;
+  }
+  return `${renderYaml(canonicalValue).join("\n")}
+`;
+}
+function parseDomainPackAuthoringManifest(source, format) {
+  const detectedFormat = detectDomainPackManifestFormat(source, format);
+  const parsed = detectedFormat === "json" ? JSON.parse(source) : parseYamlDocument(source);
+  if (!isPlainObject(parsed)) {
+    throw new Error("Domain pack manifest must parse to an object.");
+  }
+  if (!("pack" in parsed)) {
+    throw new Error("Domain pack manifest requires a top-level pack object.");
+  }
+  return defineDomainPackAuthoringManifest({
+    kind: parsed.kind,
+    manifestVersion: parsed.manifestVersion,
+    pack: parsed.pack,
+    frameworks: parsed.frameworks,
+    schemaExtensions: parsed.schemaExtensions,
+    ontologyExtensions: parsed.ontologyExtensions,
+    lineage: parsed.lineage,
+    metadata: parsed.metadata
+  });
+}
+
+// src/domain-pack/validation.ts
+function issue(code, message, path, severity = "error") {
+  return { code, severity, message, path };
+}
+var KEBAB_CASE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+var SHAPING_QUESTION_TYPES = /* @__PURE__ */ new Set([
+  "validation",
+  "falsification",
+  "assumption_probe",
+  "counterfactual",
+  "scope",
+  "comparison",
+  "mechanism",
+  "general"
+]);
+var RUNTIME_TARGETS = /* @__PURE__ */ new Set(["claude-code", "codex", "hybrid", "portable"]);
+var ONTOLOGY_PROVISION_MODES = /* @__PURE__ */ new Set(["bind", "seed", "extend"]);
+function validateStringArray(values, path, label) {
+  if (!values) {
+    return [];
+  }
+  return values.flatMap((value, index) => {
+    if (!value?.trim()) {
+      return [
         issue(
-          "UNKNOWN_SETUP_ASSET_REF",
-          `install profile references unknown setup asset "${assetId}"`,
-          `${path}.assetIds[${assetIndex}]`
+          "INVALID_SHAPING_CONDITION",
+          `${label} must not contain empty strings`,
+          `${path}[${index}]`
         )
-      );
+      ];
     }
-  }
-  for (const [topicIndex, topicSlug] of profile.defaultTopicSlugs.entries()) {
-    if (!knownTopicSlugs.has(topicSlug)) {
+    return [];
+  });
+}
+function validateRuntimeTargets(values, path) {
+  const issues = validateStringArray(values, path, "runtimeTargets");
+  for (const [index, value] of (values || []).entries()) {
+    if (!RUNTIME_TARGETS.has(value)) {
       issues.push(
         issue(
-          "UNKNOWN_TOPIC_REF",
-          `install profile references unknown topic "${topicSlug}"`,
-          `${path}.defaultTopicSlugs[${topicIndex}]`
+          "INVALID_RUNTIME_TARGET",
+          `Unsupported runtime target "${value}"`,
+          `${path}[${index}]`
         )
       );
     }
   }
   return issues;
 }
-function checkDuplicateIds(items, idField, path) {
+function validatePromptBinding(prompt, index) {
+  const path = `operatingSystem.prompts[${index}]`;
   const issues = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const item of items) {
-    const id = item[idField];
-    if (seen.has(id)) {
-      issues.push(
-        issue(
-          "DUPLICATE_ID",
-          `Duplicate ${idField} "${id}"`,
-          `${path}.${idField}`
-        )
-      );
-    }
-    seen.add(id);
+  if (!prompt.promptId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_PROMPT_ID",
+        "prompt binding requires promptId",
+        `${path}.promptId`
+      )
+    );
+  }
+  if (!prompt.ref?.trim()) {
+    issues.push(
+      issue("MISSING_PROMPT_REF", "prompt binding requires ref", `${path}.ref`)
+    );
   }
+  issues.push(
+    ...validateRuntimeTargets(prompt.runtimeTargets, `${path}.runtimeTargets`)
+  );
   return issues;
 }
-function validateDomainPack(pack) {
+function validateToolBinding(tool, index) {
+  const path = `operatingSystem.tools[${index}]`;
   const issues = [];
-  if (!pack.packId || !pack.packId.trim()) {
-    issues.push(issue("MISSING_PACK_ID", "packId is required", "packId"));
-  } else if (!KEBAB_CASE.test(pack.packId)) {
+  if (!tool.toolId?.trim()) {
+    issues.push(
+      issue("MISSING_TOOL_ID", "tool binding requires toolId", `${path}.toolId`)
+    );
+  }
+  if (!tool.entrypoint?.trim()) {
     issues.push(
       issue(
-        "INVALID_PACK_ID",
-        `packId "${pack.packId}" must be kebab-case`,
-        "packId"
+        "MISSING_TOOL_ENTRYPOINT",
+        "tool binding requires entrypoint",
+        `${path}.entrypoint`
       )
     );
   }
-  if (!pack.name || !pack.name.trim()) {
-    issues.push(issue("MISSING_NAME", "name is required", "name"));
-  }
-  if (!pack.version || !pack.version.trim()) {
-    issues.push(issue("MISSING_VERSION", "version is required", "version"));
-  } else if (!SEMVER.test(pack.version)) {
+  issues.push(
+    ...validateRuntimeTargets(tool.runtimeTargets, `${path}.runtimeTargets`)
+  );
+  return issues;
+}
+function validateSetupAsset(asset, index) {
+  const path = `operatingSystem.setupAssets[${index}]`;
+  const issues = [];
+  if (!asset.assetId?.trim()) {
     issues.push(
       issue(
-        "INVALID_VERSION",
-        `version "${pack.version}" must be valid semver`,
-        "version"
+        "MISSING_SETUP_ASSET_ID",
+        "setup asset requires assetId",
+        `${path}.assetId`
       )
     );
   }
-  if (!pack.ontologyBindings || pack.ontologyBindings.length === 0) {
+  if (!asset.path?.trim()) {
     issues.push(
       issue(
-        "MISSING_ONTOLOGY_BINDINGS",
-        "At least one ontologyBinding is required",
-        "ontologyBindings"
+        "MISSING_SETUP_ASSET_PATH",
+        "setup asset requires path",
+        `${path}.path`
       )
     );
-  } else {
-    for (const [i, binding] of pack.ontologyBindings.entries()) {
-      if (!binding.ontologyId?.trim()) {
-        issues.push(
-          issue(
-            "MISSING_ONTOLOGY_ID",
-            `ontologyBinding[${i}].ontologyId is required`,
-            `ontologyBindings[${i}].ontologyId`
-          )
-        );
-      }
-      if (!binding.versionConstraint?.trim()) {
-        issues.push(
-          issue(
-            "MISSING_VERSION_CONSTRAINT",
-            `ontologyBinding[${i}].versionConstraint is required`,
-            `ontologyBindings[${i}].versionConstraint`
-          )
-        );
-      }
-      if (binding.provisionMode && !ONTOLOGY_PROVISION_MODES.has(binding.provisionMode)) {
-        issues.push(
-          issue(
-            "INVALID_ONTOLOGY_PROVISION_MODE",
-            `Unsupported provisionMode "${binding.provisionMode}"`,
-            `ontologyBindings[${i}].provisionMode`
-          )
-        );
-      }
-      if (binding.provisionMode && binding.provisionMode !== "bind" && !binding.seedRef?.trim()) {
-        issues.push(
-          issue(
-            "MISSING_ONTOLOGY_SEED_REF",
-            `ontologyBinding[${i}] requires seedRef when provisionMode is "${binding.provisionMode}"`,
-            `ontologyBindings[${i}].seedRef`
-          )
-        );
-      }
-      issues.push(
-        ...validateStringArray(
-          binding.requiredEntityTypes,
-          `ontologyBindings[${i}].requiredEntityTypes`,
-          "requiredEntityTypes"
-        ),
-        ...validateStringArray(
-          binding.requiredEdgeTypes,
-          `ontologyBindings[${i}].requiredEdgeTypes`,
-          "requiredEdgeTypes"
-        )
-      );
-    }
   }
-  if (!pack.topicRoots || pack.topicRoots.length === 0) {
+  issues.push(
+    ...validateRuntimeTargets(asset.runtimeTargets, `${path}.runtimeTargets`)
+  );
+  return issues;
+}
+function validateQuestionTemplate(template, index) {
+  const path = `inquiryShaping.questionTemplates[${index}]`;
+  const issues = [];
+  if (!template.templateId?.trim()) {
     issues.push(
       issue(
-        "MISSING_TOPIC_ROOTS",
-        "At least one topicRoot is required",
-        "topicRoots"
+        "MISSING_SHAPING_TEMPLATE_ID",
+        "question template requires templateId",
+        `${path}.templateId`
       )
     );
-  } else {
+  }
+  if (!template.template?.trim()) {
     issues.push(
-      ...checkDuplicateIds(
-        pack.topicRoots,
-        "slug",
-        "topicRoots"
+      issue(
+        "MISSING_SHAPING_TEMPLATE",
+        "question template requires template text",
+        `${path}.template`
       )
     );
   }
-  if (pack.operatingSystem) {
-    const knownRootSlugs = new Set(
-      pack.topicRoots?.map((topic) => topic.slug) ?? []
-    );
-    if (pack.operatingSystem.prompts) {
-      issues.push(
-        ...checkDuplicateIds(
-          pack.operatingSystem.prompts,
-          "promptId",
-          "operatingSystem.prompts"
-        )
-      );
-      pack.operatingSystem.prompts.forEach((prompt, index) => {
-        issues.push(...validatePromptBinding(prompt, index));
-      });
-    }
-    if (pack.operatingSystem.tools) {
-      issues.push(
-        ...checkDuplicateIds(
-          pack.operatingSystem.tools,
-          "toolId",
-          "operatingSystem.tools"
-        )
-      );
-      pack.operatingSystem.tools.forEach((tool, index) => {
-        issues.push(...validateToolBinding(tool, index));
-      });
-    }
-    if (pack.operatingSystem.setupAssets) {
-      issues.push(
-        ...checkDuplicateIds(
-          pack.operatingSystem.setupAssets,
-          "assetId",
-          "operatingSystem.setupAssets"
-        )
-      );
-      pack.operatingSystem.setupAssets.forEach((asset, index) => {
-        issues.push(...validateSetupAsset(asset, index));
-      });
-    }
-    const templateSlugs = /* @__PURE__ */ new Set();
-    if (pack.operatingSystem.topicTemplates) {
-      issues.push(
-        ...checkDuplicateIds(
-          pack.operatingSystem.topicTemplates,
-          "slug",
-          "operatingSystem.topicTemplates"
-        )
-      );
-      pack.operatingSystem.topicTemplates.forEach((template) => {
-        if (template.slug) {
-          templateSlugs.add(template.slug);
-        }
-      });
-      const knownTopicSlugs = /* @__PURE__ */ new Set([...knownRootSlugs, ...templateSlugs]);
-      pack.operatingSystem.topicTemplates.forEach((template, index) => {
-        issues.push(...validateTopicTemplate(template, index, knownTopicSlugs));
-      });
-    }
-    if (pack.operatingSystem.installProfiles) {
-      issues.push(
-        ...checkDuplicateIds(
-          pack.operatingSystem.installProfiles,
-          "profileId",
-          "operatingSystem.installProfiles"
-        )
-      );
-      const knownPromptIds = new Set(
-        pack.operatingSystem.prompts?.map((prompt) => prompt.promptId) ?? []
-      );
-      const knownToolIds = new Set(
-        pack.operatingSystem.tools?.map((tool) => tool.toolId) ?? []
-      );
-      const knownAssetIds = new Set(
-        pack.operatingSystem.setupAssets?.map((asset) => asset.assetId) ?? []
-      );
-      const knownTopicSlugs = /* @__PURE__ */ new Set([...knownRootSlugs, ...templateSlugs]);
-      pack.operatingSystem.installProfiles.forEach((profile, index) => {
-        issues.push(
-          ...validateInstallProfile(
-            profile,
-            index,
-            knownPromptIds,
-            knownToolIds,
-            knownAssetIds,
-            knownTopicSlugs
-          )
-        );
-      });
-    }
-  }
-  if (!pack.roles || pack.roles.length === 0) {
-    issues.push(
-      issue("MISSING_ROLES", "At least one reasoning role is required", "roles")
-    );
-  } else {
+  if (!SHAPING_QUESTION_TYPES.has(template.questionType)) {
     issues.push(
-      ...checkDuplicateIds(
-        pack.roles,
-        "roleId",
-        "roles"
+      issue(
+        "INVALID_SHAPING_QUESTION_TYPE",
+        `Unsupported questionType "${template.questionType}"`,
+        `${path}.questionType`
       )
     );
   }
-  const knownGateIds = new Set(pack.gates?.map((g) => g.gateId) ?? []);
-  const knownArtifactIds = new Set(
-    pack.artifacts?.map((a) => a.artifactId) ?? []
+  issues.push(
+    ...validateStringArray(
+      template.whenObjectiveIncludes,
+      `${path}.whenObjectiveIncludes`,
+      "whenObjectiveIncludes"
+    )
   );
-  const knownRoleIds = new Set(pack.roles?.map((r) => r.roleId) ?? []);
-  if (pack.gates) {
+  return issues;
+}
+function validateTaskTemplate(template, index) {
+  const path = `inquiryShaping.taskTemplates[${index}]`;
+  const issues = [];
+  if (!template.templateId?.trim()) {
     issues.push(
-      ...checkDuplicateIds(
-        pack.gates,
-        "gateId",
-        "gates"
+      issue(
+        "MISSING_TASK_GENERATOR_ID",
+        "task template requires templateId",
+        `${path}.templateId`
       )
     );
-    for (const [i, gate] of pack.gates.entries()) {
-      if (!gate.criteria || gate.criteria.length === 0) {
-        issues.push(
-          issue(
-            "EMPTY_GATE_CRITERIA",
-            `Gate "${gate.gateId}" has no criteria`,
-            `gates[${i}].criteria`,
-            "warning"
-          )
-        );
-      } else {
-        issues.push(
-          ...checkDuplicateIds(
-            gate.criteria,
-            "criterionId",
-            `gates[${i}].criteria`
-          )
-        );
-      }
-    }
   }
-  if (pack.artifacts) {
+  if (!template.title?.trim()) {
     issues.push(
-      ...checkDuplicateIds(
-        pack.artifacts,
-        "artifactId",
-        "artifacts"
+      issue(
+        "MISSING_TASK_GENERATOR_TITLE",
+        "task template requires title",
+        `${path}.title`
       )
     );
   }
-  if (pack.workflows) {
-    issues.push(
-      ...checkDuplicateIds(
-        pack.workflows,
-        "workflowId",
-        "workflows"
-      )
-    );
-    for (const [wi, workflow] of pack.workflows.entries()) {
-      for (const gateId of workflow.gateCheckpoints) {
-        if (!knownGateIds.has(gateId)) {
-          issues.push(
-            issue(
-              "UNKNOWN_GATE_REF",
-              `Workflow "${workflow.workflowId}" references unknown gate "${gateId}"`,
-              `workflows[${wi}].gateCheckpoints`
-            )
-          );
-        }
-      }
-      for (const artifactId of workflow.requiredArtifacts) {
-        if (!knownArtifactIds.has(artifactId)) {
-          issues.push(
-            issue(
-              "UNKNOWN_ARTIFACT_REF",
-              `Workflow "${workflow.workflowId}" references unknown artifact "${artifactId}"`,
-              `workflows[${wi}].requiredArtifacts`
-            )
-          );
-        }
-      }
-      for (const [si, step] of workflow.steps.entries()) {
-        for (const roleId of step.requiredRoles) {
-          if (!knownRoleIds.has(roleId)) {
-            issues.push(
-              issue(
-                "UNKNOWN_ROLE_REF",
-                `Step "${step.stepId}" references unknown role "${roleId}"`,
-                `workflows[${wi}].steps[${si}].requiredRoles`
-              )
-            );
-          }
-        }
-        if (step.gateId && !knownGateIds.has(step.gateId)) {
-          issues.push(
-            issue(
-              "UNKNOWN_GATE_REF",
-              `Step "${step.stepId}" references unknown gate "${step.gateId}"`,
-              `workflows[${wi}].steps[${si}].gateId`
-            )
-          );
-        }
-        if (step.produces) {
-          for (const artifactId of step.produces) {
-            if (!knownArtifactIds.has(artifactId)) {
-              issues.push(
-                issue(
-                  "UNKNOWN_ARTIFACT_REF",
-                  `Step "${step.stepId}" references unknown artifact "${artifactId}"`,
-                  `workflows[${wi}].steps[${si}].produces`
-                )
-              );
-            }
-          }
-        }
-      }
+  issues.push(
+    ...validateStringArray(
+      template.whenObjectiveIncludes,
+      `${path}.whenObjectiveIncludes`,
+      "whenObjectiveIncludes"
+    )
+  );
+  issues.push(
+    ...validateStringArray(
+      template.whenQuestionTypes,
+      `${path}.whenQuestionTypes`,
+      "whenQuestionTypes"
+    )
+  );
+  for (const [questionTypeIndex, questionType] of (template.whenQuestionTypes || []).entries()) {
+    if (!SHAPING_QUESTION_TYPES.has(questionType)) {
+      issues.push(
+        issue(
+          "INVALID_TASK_GENERATOR_QUESTION_TYPE",
+          `Unsupported whenQuestionTypes value "${questionType}"`,
+          `${path}.whenQuestionTypes[${questionTypeIndex}]`
+        )
+      );
     }
   }
-  if (pack.inquiryShaping) {
-    if (pack.inquiryShaping.questionTemplates) {
+  return issues;
+}
+function validateFrameworkHint(hint, index) {
+  const path = `inquiryShaping.frameworkHints[${index}]`;
+  const issues = [];
+  if (!hint.frameworkName?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_FRAMEWORK_HOOK_NAME",
+        "framework hint requires frameworkName",
+        `${path}.frameworkName`
+      )
+    );
+  }
+  if (hint.boost != null && (!Number.isFinite(hint.boost) || hint.boost < 0)) {
+    issues.push(
+      issue(
+        "INVALID_FRAMEWORK_HOOK_BOOST",
+        "framework hint boost must be a non-negative number",
+        `${path}.boost`
+      )
+    );
+  }
+  issues.push(
+    ...validateStringArray(
+      hint.whenObjectiveIncludes,
+      `${path}.whenObjectiveIncludes`,
+      "whenObjectiveIncludes"
+    )
+  );
+  issues.push(
+    ...validateStringArray(
+      hint.whenQuestionTypes,
+      `${path}.whenQuestionTypes`,
+      "whenQuestionTypes"
+    )
+  );
+  for (const [questionTypeIndex, questionType] of (hint.whenQuestionTypes || []).entries()) {
+    if (!SHAPING_QUESTION_TYPES.has(questionType)) {
       issues.push(
-        ...checkDuplicateIds(
-          pack.inquiryShaping.questionTemplates,
-          "templateId",
-          "inquiryShaping.questionTemplates"
+        issue(
+          "INVALID_FRAMEWORK_HOOK_QUESTION_TYPE",
+          `Unsupported whenQuestionTypes value "${questionType}"`,
+          `${path}.whenQuestionTypes[${questionTypeIndex}]`
         )
       );
-      pack.inquiryShaping.questionTemplates.forEach((template, index) => {
-        issues.push(...validateQuestionTemplate(template, index));
-      });
     }
-    if (pack.inquiryShaping.taskTemplates) {
+  }
+  return issues;
+}
+function validateTopicTemplate(template, index, knownTopicSlugs) {
+  const path = `operatingSystem.topicTemplates[${index}]`;
+  const issues = [];
+  if (!template.slug?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_TEMPLATE_SLUG",
+        "topic template requires slug",
+        `${path}.slug`
+      )
+    );
+  } else if (!KEBAB_CASE.test(template.slug)) {
+    issues.push(
+      issue(
+        "INVALID_TOPIC_TEMPLATE_SLUG",
+        `topic template slug "${template.slug}" must be kebab-case`,
+        `${path}.slug`
+      )
+    );
+  }
+  if (!template.name?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_TEMPLATE_NAME",
+        "topic template requires name",
+        `${path}.name`
+      )
+    );
+  }
+  if (!template.description?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_TEMPLATE_DESCRIPTION",
+        "topic template requires description",
+        `${path}.description`
+      )
+    );
+  }
+  if (template.parentSlug && !knownTopicSlugs.has(template.parentSlug)) {
+    issues.push(
+      issue(
+        "UNKNOWN_TOPIC_PARENT",
+        `topic template references unknown parent "${template.parentSlug}"`,
+        `${path}.parentSlug`
+      )
+    );
+  }
+  return issues;
+}
+function validateInstallProfile(profile, index, knownPromptIds, knownToolIds, knownAssetIds, knownTopicSlugs) {
+  const path = `operatingSystem.installProfiles[${index}]`;
+  const issues = [];
+  if (!profile.profileId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_INSTALL_PROFILE_ID",
+        "install profile requires profileId",
+        `${path}.profileId`
+      )
+    );
+  }
+  if (!profile.name?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_INSTALL_PROFILE_NAME",
+        "install profile requires name",
+        `${path}.name`
+      )
+    );
+  }
+  if (!profile.description?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_INSTALL_PROFILE_DESCRIPTION",
+        "install profile requires description",
+        `${path}.description`
+      )
+    );
+  }
+  if (!RUNTIME_TARGETS.has(profile.runtimeTarget)) {
+    issues.push(
+      issue(
+        "INVALID_RUNTIME_TARGET",
+        `Unsupported runtime target "${profile.runtimeTarget}"`,
+        `${path}.runtimeTarget`
+      )
+    );
+  }
+  for (const [promptIndex, promptId] of profile.promptIds.entries()) {
+    if (!knownPromptIds.has(promptId)) {
       issues.push(
-        ...checkDuplicateIds(
-          pack.inquiryShaping.taskTemplates,
-          "templateId",
-          "inquiryShaping.taskTemplates"
+        issue(
+          "UNKNOWN_PROMPT_REF",
+          `install profile references unknown prompt "${promptId}"`,
+          `${path}.promptIds[${promptIndex}]`
         )
       );
-      pack.inquiryShaping.taskTemplates.forEach((template, index) => {
-        issues.push(...validateTaskTemplate(template, index));
-      });
     }
-    if (pack.inquiryShaping.frameworkHints) {
+  }
+  for (const [toolIndex, toolId] of profile.toolIds.entries()) {
+    if (!knownToolIds.has(toolId)) {
       issues.push(
-        ...checkDuplicateIds(
-          pack.inquiryShaping.frameworkHints.map((hint) => ({
-            frameworkName: hint.frameworkName
-          })),
-          "frameworkName",
-          "inquiryShaping.frameworkHints"
+        issue(
+          "UNKNOWN_TOOL_REF",
+          `install profile references unknown tool "${toolId}"`,
+          `${path}.toolIds[${toolIndex}]`
         )
       );
-      pack.inquiryShaping.frameworkHints.forEach((hint, index) => {
-        issues.push(...validateFrameworkHint(hint, index));
-      });
     }
   }
-  return {
-    valid: issues.filter((i) => i.severity === "error").length === 0,
-    issues
-  };
-}
-
-// src/domain-pack/authoring.ts
-var DOMAIN_PACK_MANIFEST_KIND = "lucern-domain-pack-manifest";
-var CURRENT_MANIFEST_VERSION = "1.0.0";
-var KEBAB_CASE2 = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
-var SEMVER2 = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
-var LEGACY_PUBLIC_KEYS = /* @__PURE__ */ new Set([
-  "project",
-  "projects",
-  "projectId",
-  "projectIds"
-]);
-var SCHEMA_EXTENSION_TARGETS = /* @__PURE__ */ new Set([
-  "artifact",
-  "workflow",
-  "gate",
-  "prompt",
-  "tool",
-  "install-profile",
-  "topic-template"
-]);
-var ONTOLOGY_CONSTRAINT_SEVERITIES = /* @__PURE__ */ new Set([
-  "error",
-  "warning",
-  "informational"
-]);
-var LINEAGE_MODES = /* @__PURE__ */ new Set(["root", "remix", "fork"]);
-var AUTHORING_TOOL_NAMES = {
-  validate: "validate_domain_pack_manifest",
-  preview: "preview_domain_pack_manifest",
-  publish: "publish_domain_pack_manifest"
-};
-function issue2(code, message, path, source, severity = "error") {
-  return { code, message, path, severity, source };
-}
-function emptyCounts() {
-  return {
-    topicRoots: 0,
-    workflows: 0,
-    gates: 0,
-    artifacts: 0,
-    roles: 0,
-    prompts: 0,
-    tools: 0,
-    setupAssets: 0,
-    installProfiles: 0,
-    frameworks: 0,
-    schemaExtensions: 0,
-    ontologyExtensions: 0
-  };
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
-}
-function describeParseFailure(error) {
-  return error instanceof Error ? error.message : "Manifest parse failed.";
-}
-function dedupeStrings2(values) {
-  if (!values) {
-    return void 0;
-  }
-  return Array.from(
-    new Set(values.map((value) => value.trim()).filter((value) => value.length))
-  );
-}
-function normalizeRuntimeTargets2(values) {
-  return values ? dedupeStrings2(values) : void 0;
-}
-function normalizeFrameworks(frameworks) {
-  if (!frameworks) {
-    return void 0;
-  }
-  return frameworks.map((framework) => ({
-    ...framework,
-    frameworkId: framework.frameworkId.trim(),
-    version: framework.version.trim(),
-    versionConstraint: framework.versionConstraint?.trim(),
-    runtimeTargets: normalizeRuntimeTargets2(framework.runtimeTargets)
-  }));
-}
-function normalizeSchemaExtensions(extensions) {
-  if (!extensions) {
-    return void 0;
-  }
-  return extensions.map((extension) => ({
-    ...extension,
-    extensionId: extension.extensionId.trim(),
-    target: extension.target,
-    description: extension.description.trim(),
-    version: extension.version.trim(),
-    extends: extension.extends?.trim()
-  }));
-}
-function normalizeOntologyExtensions(extensions) {
-  if (!extensions) {
-    return void 0;
-  }
-  return extensions.map((extension) => ({
-    ...extension,
-    extensionId: extension.extensionId.trim(),
-    ontologyId: extension.ontologyId.trim(),
-    baseVersionConstraint: extension.baseVersionConstraint.trim(),
-    entityTypes: extension.entityTypes?.map((entityType) => ({
-      ...entityType,
-      value: entityType.value.trim(),
-      label: entityType.label.trim(),
-      description: entityType.description?.trim(),
-      subtypes: dedupeStrings2(entityType.subtypes)
-    })),
-    edgeTypes: extension.edgeTypes?.map((edgeType) => ({
-      ...edgeType,
-      value: edgeType.value.trim(),
-      label: edgeType.label.trim(),
-      description: edgeType.description?.trim(),
-      sourceTypes: dedupeStrings2(edgeType.sourceTypes),
-      targetTypes: dedupeStrings2(edgeType.targetTypes)
-    }))
-  }));
-}
-function normalizeLineage(lineage) {
-  if (!lineage) {
-    return { mode: "root" };
+  for (const [assetIndex, assetId] of profile.assetIds.entries()) {
+    if (!knownAssetIds.has(assetId)) {
+      issues.push(
+        issue(
+          "UNKNOWN_SETUP_ASSET_REF",
+          `install profile references unknown setup asset "${assetId}"`,
+          `${path}.assetIds[${assetIndex}]`
+        )
+      );
+    }
   }
-  return {
-    mode: lineage.mode,
-    parentPackId: lineage.parentPackId?.trim(),
-    parentVersion: lineage.parentVersion?.trim(),
-    parentManifestDigest: lineage.parentManifestDigest?.trim(),
-    supersedesPackId: lineage.supersedesPackId?.trim(),
-    notes: lineage.notes?.trim()
-  };
-}
-function normalizeMetadata(metadata) {
-  if (!metadata) {
-    return void 0;
+  for (const [topicIndex, topicSlug] of profile.defaultTopicSlugs.entries()) {
+    if (!knownTopicSlugs.has(topicSlug)) {
+      issues.push(
+        issue(
+          "UNKNOWN_TOPIC_REF",
+          `install profile references unknown topic "${topicSlug}"`,
+          `${path}.defaultTopicSlugs[${topicIndex}]`
+        )
+      );
+    }
   }
-  return {
-    description: metadata.description?.trim(),
-    owner: metadata.owner?.trim(),
-    tags: dedupeStrings2(metadata.tags)
-  };
-}
-function toDomainPack(pack) {
-  return defineDomainPack(pack);
-}
-function defineDomainPackAuthoringManifest(input) {
-  return {
-    kind: input.kind ?? DOMAIN_PACK_MANIFEST_KIND,
-    manifestVersion: input.manifestVersion?.trim() || CURRENT_MANIFEST_VERSION,
-    pack: toDomainPack(input.pack),
-    frameworks: normalizeFrameworks(input.frameworks),
-    schemaExtensions: normalizeSchemaExtensions(input.schemaExtensions),
-    ontologyExtensions: normalizeOntologyExtensions(input.ontologyExtensions),
-    lineage: normalizeLineage(input.lineage),
-    metadata: normalizeMetadata(input.metadata)
-  };
+  return issues;
 }
-function countManifestArtifacts(manifest) {
-  if (!manifest) {
-    return emptyCounts();
+function checkDuplicateIds(items, idField, path) {
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const id = item[idField];
+    if (seen.has(id)) {
+      issues.push(
+        issue(
+          "DUPLICATE_ID",
+          `Duplicate ${idField} "${id}"`,
+          `${path}.${idField}`
+        )
+      );
+    }
+    seen.add(id);
   }
-  return {
-    topicRoots: manifest.pack.topicRoots.length,
-    workflows: manifest.pack.workflows.length,
-    gates: manifest.pack.gates.length,
-    artifacts: manifest.pack.artifacts.length,
-    roles: manifest.pack.roles.length,
-    prompts: manifest.pack.operatingSystem?.prompts?.length ?? 0,
-    tools: manifest.pack.operatingSystem?.tools?.length ?? 0,
-    setupAssets: manifest.pack.operatingSystem?.setupAssets?.length ?? 0,
-    installProfiles: manifest.pack.operatingSystem?.installProfiles?.length ?? 0,
-    frameworks: manifest.frameworks?.length ?? 0,
-    schemaExtensions: manifest.schemaExtensions?.length ?? 0,
-    ontologyExtensions: manifest.ontologyExtensions?.length ?? 0
-  };
+  return issues;
 }
-function sortJsonValue(value) {
-  if (Array.isArray(value)) {
-    return value.map(sortJsonValue);
-  }
-  if (isPlainObject(value)) {
-    return Object.fromEntries(
-      Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => [key, sortJsonValue(entryValue)])
+function validateDomainPack(pack) {
+  const issues = [];
+  if (!pack.packId || !pack.packId.trim()) {
+    issues.push(issue("MISSING_PACK_ID", "packId is required", "packId"));
+  } else if (!KEBAB_CASE.test(pack.packId)) {
+    issues.push(
+      issue(
+        "INVALID_PACK_ID",
+        `packId "${pack.packId}" must be kebab-case`,
+        "packId"
+      )
     );
   }
-  return value;
-}
-function toYamlScalar(value) {
-  if (value === null) {
-    return "null";
+  if (!pack.name || !pack.name.trim()) {
+    issues.push(issue("MISSING_NAME", "name is required", "name"));
   }
-  if (typeof value === "boolean" || typeof value === "number") {
-    return String(value);
+  if (!pack.version || !pack.version.trim()) {
+    issues.push(issue("MISSING_VERSION", "version is required", "version"));
+  } else if (!SEMVER.test(pack.version)) {
+    issues.push(
+      issue(
+        "INVALID_VERSION",
+        `version "${pack.version}" must be valid semver`,
+        "version"
+      )
+    );
   }
-  return JSON.stringify(String(value));
-}
-function renderYaml(value, indent = 0) {
-  const prefix = " ".repeat(indent);
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return [`${prefix}[]`];
-    }
-    return value.flatMap((entry) => {
-      if (Array.isArray(entry) || isPlainObject(entry)) {
-        return [`${prefix}-`, ...renderYaml(entry, indent + 2)];
+  if (!pack.ontologyBindings || pack.ontologyBindings.length === 0) {
+    issues.push(
+      issue(
+        "MISSING_ONTOLOGY_BINDINGS",
+        "At least one ontologyBinding is required",
+        "ontologyBindings"
+      )
+    );
+  } else {
+    for (const [i, binding] of pack.ontologyBindings.entries()) {
+      if (!binding.ontologyId?.trim()) {
+        issues.push(
+          issue(
+            "MISSING_ONTOLOGY_ID",
+            `ontologyBinding[${i}].ontologyId is required`,
+            `ontologyBindings[${i}].ontologyId`
+          )
+        );
       }
-      return [`${prefix}- ${toYamlScalar(entry)}`];
-    });
-  }
-  if (isPlainObject(value)) {
-    const entries = Object.entries(value);
-    if (entries.length === 0) {
-      return [`${prefix}{}`];
-    }
-    return entries.flatMap(([key, entryValue]) => {
-      if (entryValue === void 0) {
-        return [];
+      if (!binding.versionConstraint?.trim()) {
+        issues.push(
+          issue(
+            "MISSING_VERSION_CONSTRAINT",
+            `ontologyBinding[${i}].versionConstraint is required`,
+            `ontologyBindings[${i}].versionConstraint`
+          )
+        );
       }
-      if (Array.isArray(entryValue)) {
-        if (entryValue.length === 0) {
-          return [`${prefix}${key}: []`];
-        }
-        return [`${prefix}${key}:`, ...renderYaml(entryValue, indent + 2)];
+      if (binding.provisionMode && !ONTOLOGY_PROVISION_MODES.has(binding.provisionMode)) {
+        issues.push(
+          issue(
+            "INVALID_ONTOLOGY_PROVISION_MODE",
+            `Unsupported provisionMode "${binding.provisionMode}"`,
+            `ontologyBindings[${i}].provisionMode`
+          )
+        );
       }
-      if (isPlainObject(entryValue)) {
-        if (Object.keys(entryValue).length === 0) {
-          return [`${prefix}${key}: {}`];
-        }
-        return [`${prefix}${key}:`, ...renderYaml(entryValue, indent + 2)];
+      if (binding.provisionMode && binding.provisionMode !== "bind" && !binding.seedRef?.trim()) {
+        issues.push(
+          issue(
+            "MISSING_ONTOLOGY_SEED_REF",
+            `ontologyBinding[${i}] requires seedRef when provisionMode is "${binding.provisionMode}"`,
+            `ontologyBindings[${i}].seedRef`
+          )
+        );
       }
-      return [`${prefix}${key}: ${toYamlScalar(entryValue)}`];
-    });
-  }
-  return [`${prefix}${toYamlScalar(value)}`];
-}
-function countIndent(line) {
-  return line.length - line.trimStart().length;
-}
-function parseYamlScalar(raw) {
-  const value = raw.trim();
-  if (value === "null") {
-    return null;
-  }
-  if (value === "true") {
-    return true;
-  }
-  if (value === "false") {
-    return false;
-  }
-  if (/^-?\d+(?:\.\d+)?$/.test(value)) {
-    return Number(value);
-  }
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    if (value.startsWith("'")) {
-      return value.slice(1, -1).replace(/''/g, "'");
+      issues.push(
+        ...validateStringArray(
+          binding.requiredEntityTypes,
+          `ontologyBindings[${i}].requiredEntityTypes`,
+          "requiredEntityTypes"
+        ),
+        ...validateStringArray(
+          binding.requiredEdgeTypes,
+          `ontologyBindings[${i}].requiredEdgeTypes`,
+          "requiredEdgeTypes"
+        )
+      );
     }
-    return JSON.parse(value);
-  }
-  if (value === "[]") {
-    return [];
   }
-  if (value === "{}") {
-    return {};
-  }
-  return value;
-}
-function splitYamlKeyValue(trimmed) {
-  const separatorIndex = trimmed.indexOf(":");
-  if (separatorIndex === -1) {
-    throw new Error(`Invalid YAML mapping entry: ${trimmed}`);
+  if (!pack.topicRoots || pack.topicRoots.length === 0) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_ROOTS",
+        "At least one topicRoot is required",
+        "topicRoots"
+      )
+    );
+  } else {
+    issues.push(
+      ...checkDuplicateIds(
+        pack.topicRoots,
+        "slug",
+        "topicRoots"
+      )
+    );
   }
-  const key = trimmed.slice(0, separatorIndex).trim();
-  const value = trimmed.slice(separatorIndex + 1).trim();
-  return { key, value: value.length ? value : null };
-}
-function parseYamlDocument(text) {
-  const rawLines = text.replace(/\r\n/g, "\n").split("\n").map((line) => line.replace(/\t/g, "  "));
-  const lines = rawLines.filter((line) => {
-    const trimmed = line.trim();
-    return trimmed.length > 0 && trimmed !== "---" && trimmed !== "...";
-  });
-  let index = 0;
-  function parseBlock(indent) {
-    if (index >= lines.length) {
-      return {};
+  if (pack.operatingSystem) {
+    const knownRootSlugs = new Set(
+      pack.topicRoots?.map((topic) => topic.slug) ?? []
+    );
+    if (pack.operatingSystem.prompts) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.operatingSystem.prompts,
+          "promptId",
+          "operatingSystem.prompts"
+        )
+      );
+      pack.operatingSystem.prompts.forEach((prompt, index) => {
+        issues.push(...validatePromptBinding(prompt, index));
+      });
     }
-    const currentLine = lines[index];
-    const currentIndent = countIndent(currentLine);
-    if (currentIndent < indent) {
-      return {};
+    if (pack.operatingSystem.tools) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.operatingSystem.tools,
+          "toolId",
+          "operatingSystem.tools"
+        )
+      );
+      pack.operatingSystem.tools.forEach((tool, index) => {
+        issues.push(...validateToolBinding(tool, index));
+      });
     }
-    if (currentLine.trimStart().startsWith("-")) {
-      return parseArray(indent);
+    if (pack.operatingSystem.setupAssets) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.operatingSystem.setupAssets,
+          "assetId",
+          "operatingSystem.setupAssets"
+        )
+      );
+      pack.operatingSystem.setupAssets.forEach((asset, index) => {
+        issues.push(...validateSetupAsset(asset, index));
+      });
+    }
+    const templateSlugs = /* @__PURE__ */ new Set();
+    if (pack.operatingSystem.topicTemplates) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.operatingSystem.topicTemplates,
+          "slug",
+          "operatingSystem.topicTemplates"
+        )
+      );
+      pack.operatingSystem.topicTemplates.forEach((template) => {
+        if (template.slug) {
+          templateSlugs.add(template.slug);
+        }
+      });
+      const knownTopicSlugs = /* @__PURE__ */ new Set([...knownRootSlugs, ...templateSlugs]);
+      pack.operatingSystem.topicTemplates.forEach((template, index) => {
+        issues.push(...validateTopicTemplate(template, index, knownTopicSlugs));
+      });
+    }
+    if (pack.operatingSystem.installProfiles) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.operatingSystem.installProfiles,
+          "profileId",
+          "operatingSystem.installProfiles"
+        )
+      );
+      const knownPromptIds = new Set(
+        pack.operatingSystem.prompts?.map((prompt) => prompt.promptId) ?? []
+      );
+      const knownToolIds = new Set(
+        pack.operatingSystem.tools?.map((tool) => tool.toolId) ?? []
+      );
+      const knownAssetIds = new Set(
+        pack.operatingSystem.setupAssets?.map((asset) => asset.assetId) ?? []
+      );
+      const knownTopicSlugs = /* @__PURE__ */ new Set([...knownRootSlugs, ...templateSlugs]);
+      pack.operatingSystem.installProfiles.forEach((profile, index) => {
+        issues.push(
+          ...validateInstallProfile(
+            profile,
+            index,
+            knownPromptIds,
+            knownToolIds,
+            knownAssetIds,
+            knownTopicSlugs
+          )
+        );
+      });
     }
-    return parseObject(indent);
   }
-  function parseArray(indent) {
-    const items = [];
-    while (index < lines.length) {
-      const line = lines[index];
-      const currentIndent = countIndent(line);
-      if (currentIndent < indent) {
-        break;
+  if (!pack.roles || pack.roles.length === 0) {
+    issues.push(
+      issue("MISSING_ROLES", "At least one reasoning role is required", "roles")
+    );
+  } else {
+    issues.push(
+      ...checkDuplicateIds(
+        pack.roles,
+        "roleId",
+        "roles"
+      )
+    );
+  }
+  const knownGateIds = new Set(pack.gates?.map((g) => g.gateId) ?? []);
+  const knownArtifactIds = new Set(
+    pack.artifacts?.map((a) => a.artifactId) ?? []
+  );
+  const knownRoleIds = new Set(pack.roles?.map((r) => r.roleId) ?? []);
+  if (pack.gates) {
+    issues.push(
+      ...checkDuplicateIds(
+        pack.gates,
+        "gateId",
+        "gates"
+      )
+    );
+    for (const [i, gate] of pack.gates.entries()) {
+      if (!gate.criteria || gate.criteria.length === 0) {
+        issues.push(
+          issue(
+            "EMPTY_GATE_CRITERIA",
+            `Gate "${gate.gateId}" has no criteria`,
+            `gates[${i}].criteria`,
+            "warning"
+          )
+        );
+      } else {
+        issues.push(
+          ...checkDuplicateIds(
+            gate.criteria,
+            "criterionId",
+            `gates[${i}].criteria`
+          )
+        );
       }
-      if (currentIndent !== indent) {
-        throw new Error(`Invalid YAML indentation near: ${line.trim()}`);
+    }
+  }
+  if (pack.artifacts) {
+    issues.push(
+      ...checkDuplicateIds(
+        pack.artifacts,
+        "artifactId",
+        "artifacts"
+      )
+    );
+  }
+  if (pack.workflows) {
+    issues.push(
+      ...checkDuplicateIds(
+        pack.workflows,
+        "workflowId",
+        "workflows"
+      )
+    );
+    for (const [wi, workflow] of pack.workflows.entries()) {
+      for (const gateId of workflow.gateCheckpoints) {
+        if (!knownGateIds.has(gateId)) {
+          issues.push(
+            issue(
+              "UNKNOWN_GATE_REF",
+              `Workflow "${workflow.workflowId}" references unknown gate "${gateId}"`,
+              `workflows[${wi}].gateCheckpoints`
+            )
+          );
+        }
       }
-      const trimmed = line.trimStart();
-      if (!trimmed.startsWith("-")) {
-        break;
+      for (const artifactId of workflow.requiredArtifacts) {
+        if (!knownArtifactIds.has(artifactId)) {
+          issues.push(
+            issue(
+              "UNKNOWN_ARTIFACT_REF",
+              `Workflow "${workflow.workflowId}" references unknown artifact "${artifactId}"`,
+              `workflows[${wi}].requiredArtifacts`
+            )
+          );
+        }
       }
-      const rest = trimmed.slice(1).trimStart();
-      index += 1;
-      if (!rest.length) {
-        items.push(parseBlock(indent + 2));
-        continue;
+      for (const [si, step] of workflow.steps.entries()) {
+        for (const roleId of step.requiredRoles) {
+          if (!knownRoleIds.has(roleId)) {
+            issues.push(
+              issue(
+                "UNKNOWN_ROLE_REF",
+                `Step "${step.stepId}" references unknown role "${roleId}"`,
+                `workflows[${wi}].steps[${si}].requiredRoles`
+              )
+            );
+          }
+        }
+        if (step.gateId && !knownGateIds.has(step.gateId)) {
+          issues.push(
+            issue(
+              "UNKNOWN_GATE_REF",
+              `Step "${step.stepId}" references unknown gate "${step.gateId}"`,
+              `workflows[${wi}].steps[${si}].gateId`
+            )
+          );
+        }
+        if (step.produces) {
+          for (const artifactId of step.produces) {
+            if (!knownArtifactIds.has(artifactId)) {
+              issues.push(
+                issue(
+                  "UNKNOWN_ARTIFACT_REF",
+                  `Step "${step.stepId}" references unknown artifact "${artifactId}"`,
+                  `workflows[${wi}].steps[${si}].produces`
+                )
+              );
+            }
+          }
+        }
       }
-      items.push(parseYamlScalar(rest));
     }
-    return items;
   }
-  function parseObject(indent) {
-    const objectValue = {};
-    while (index < lines.length) {
-      const line = lines[index];
-      const currentIndent = countIndent(line);
-      if (currentIndent < indent) {
-        break;
-      }
-      if (currentIndent !== indent) {
-        throw new Error(`Invalid YAML indentation near: ${line.trim()}`);
-      }
-      const trimmed = line.trim();
-      if (trimmed.startsWith("-")) {
-        break;
-      }
-      const { key, value } = splitYamlKeyValue(trimmed);
-      index += 1;
-      objectValue[key] = value === null ? parseBlock(indent + 2) : parseYamlScalar(value);
+  if (pack.inquiryShaping) {
+    if (pack.inquiryShaping.questionTemplates) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.inquiryShaping.questionTemplates,
+          "templateId",
+          "inquiryShaping.questionTemplates"
+        )
+      );
+      pack.inquiryShaping.questionTemplates.forEach((template, index) => {
+        issues.push(...validateQuestionTemplate(template, index));
+      });
+    }
+    if (pack.inquiryShaping.taskTemplates) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.inquiryShaping.taskTemplates,
+          "templateId",
+          "inquiryShaping.taskTemplates"
+        )
+      );
+      pack.inquiryShaping.taskTemplates.forEach((template, index) => {
+        issues.push(...validateTaskTemplate(template, index));
+      });
+    }
+    if (pack.inquiryShaping.frameworkHints) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.inquiryShaping.frameworkHints.map((hint) => ({
+            frameworkName: hint.frameworkName
+          })),
+          "frameworkName",
+          "inquiryShaping.frameworkHints"
+        )
+      );
+      pack.inquiryShaping.frameworkHints.forEach((hint, index) => {
+        issues.push(...validateFrameworkHint(hint, index));
+      });
     }
-    return objectValue;
   }
-  return parseBlock(0);
+  return {
+    valid: issues.filter((i) => i.severity === "error").length === 0,
+    issues
+  };
 }
-function detectDomainPackManifestFormat(source, explicitFormat) {
+
+// src/domain-pack/authoring.validation.ts
+var KEBAB_CASE2 = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var SEMVER2 = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+var LEGACY_PUBLIC_KEYS = /* @__PURE__ */ new Set([
+  "project",
+  "projects",
+  "projectId",
+  "projectIds",
+  "sprint",
+  "sprints",
+  "sprintId",
+  "sprintIds"
+]);
+var SCHEMA_EXTENSION_TARGETS = /* @__PURE__ */ new Set([
+  "artifact",
+  "workflow",
+  "gate",
+  "prompt",
+  "tool",
+  "install-profile",
+  "topic-template"
+]);
+var ONTOLOGY_CONSTRAINT_SEVERITIES = /* @__PURE__ */ new Set([
+  "error",
+  "warning",
+  "informational"
+]);
+var LINEAGE_MODES = /* @__PURE__ */ new Set(["root", "remix", "fork"]);
+var AUTHORING_TOOL_NAMES = {
+  validate: "validate_domain_pack_manifest",
+  preview: "preview_domain_pack_manifest",
+  publish: "publish_domain_pack_manifest"
+};
+function issue2(code, message, path, source, severity = "error") {
+  return { code, message, path, severity, source };
+}
+function emptyCounts() {
+  return {
+    topicRoots: 0,
+    workflows: 0,
+    gates: 0,
+    artifacts: 0,
+    roles: 0,
+    prompts: 0,
+    tools: 0,
+    setupAssets: 0,
+    installProfiles: 0,
+    frameworks: 0,
+    schemaExtensions: 0,
+    ontologyExtensions: 0
+  };
+}
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function describeParseFailure(error) {
+  return error instanceof Error ? error.message : "Manifest parse failed.";
+}
+function asToolDefinition(tool) {
+  return tool;
+}
+function detectDomainPackManifestFormat2(source, explicitFormat) {
   if (explicitFormat) {
     return explicitFormat;
   }
@@ -1185,35 +1249,6 @@ function detectDomainPackManifestFormat(source, explicitFormat) {
   }
   return "yaml";
 }
-function serializeDomainPackAuthoringManifest(manifest, format = "json") {
-  const canonicalValue = sortJsonValue(manifest);
-  if (format === "json") {
-    return `${JSON.stringify(canonicalValue, null, 2)}
-`;
-  }
-  return `${renderYaml(canonicalValue).join("\n")}
-`;
-}
-function parseDomainPackAuthoringManifest(source, format) {
-  const detectedFormat = detectDomainPackManifestFormat(source, format);
-  const parsed = detectedFormat === "json" ? JSON.parse(source) : parseYamlDocument(source);
-  if (!isPlainObject(parsed)) {
-    throw new Error("Domain pack manifest must parse to an object.");
-  }
-  if (!("pack" in parsed)) {
-    throw new Error("Domain pack manifest requires a top-level pack object.");
-  }
-  return defineDomainPackAuthoringManifest({
-    kind: parsed.kind,
-    manifestVersion: parsed.manifestVersion,
-    pack: parsed.pack,
-    frameworks: parsed.frameworks,
-    schemaExtensions: parsed.schemaExtensions,
-    ontologyExtensions: parsed.ontologyExtensions,
-    lineage: parsed.lineage,
-    metadata: parsed.metadata
-  });
-}
 function validateFrameworks(frameworks) {
   if (!frameworks) {
     return [];
@@ -1342,7 +1377,7 @@ function validateSchemaExtensions(extensions) {
         )
       );
     }
-    if (!isPlainObject(extension.schema)) {
+    if (!isPlainObject2(extension.schema)) {
       issues.push(
         issue2(
           "INVALID_SCHEMA_EXTENSION_SCHEMA",
@@ -1424,85 +1459,89 @@ function validateOntologyExtensions(extensions) {
       );
     }
     const entityTypeValues = /* @__PURE__ */ new Set();
-    extension.entityTypes?.forEach((entityType, entityTypeIndex) => {
-      const entityPath = `${path}.entityTypes[${entityTypeIndex}]`;
-      if (!entityType.value || !KEBAB_CASE2.test(entityType.value)) {
-        issues.push(
-          issue2(
-            "INVALID_ONTOLOGY_ENTITY_VALUE",
-            "entity extension value must be kebab-case",
-            `${entityPath}.value`,
-            "ontology-extension"
-          )
-        );
-      } else if (entityTypeValues.has(entityType.value)) {
-        issues.push(
-          issue2(
-            "DUPLICATE_ONTOLOGY_ENTITY_VALUE",
-            `Duplicate entity extension value "${entityType.value}"`,
-            `${entityPath}.value`,
-            "ontology-extension"
-          )
-        );
-      } else {
-        entityTypeValues.add(entityType.value);
-      }
-      if (!entityType.label) {
-        issues.push(
-          issue2(
-            "MISSING_ONTOLOGY_ENTITY_LABEL",
-            "entity extension label is required",
-            `${entityPath}.label`,
-            "ontology-extension"
-          )
-        );
+    extension.entityTypes?.forEach(
+      (entityType, entityTypeIndex) => {
+        const entityPath = `${path}.entityTypes[${entityTypeIndex}]`;
+        if (!entityType.value || !KEBAB_CASE2.test(entityType.value)) {
+          issues.push(
+            issue2(
+              "INVALID_ONTOLOGY_ENTITY_VALUE",
+              "entity extension value must be kebab-case",
+              `${entityPath}.value`,
+              "ontology-extension"
+            )
+          );
+        } else if (entityTypeValues.has(entityType.value)) {
+          issues.push(
+            issue2(
+              "DUPLICATE_ONTOLOGY_ENTITY_VALUE",
+              `Duplicate entity extension value "${entityType.value}"`,
+              `${entityPath}.value`,
+              "ontology-extension"
+            )
+          );
+        } else {
+          entityTypeValues.add(entityType.value);
+        }
+        if (!entityType.label) {
+          issues.push(
+            issue2(
+              "MISSING_ONTOLOGY_ENTITY_LABEL",
+              "entity extension label is required",
+              `${entityPath}.label`,
+              "ontology-extension"
+            )
+          );
+        }
       }
-    });
+    );
     const edgeTypeValues = /* @__PURE__ */ new Set();
-    extension.edgeTypes?.forEach((edgeType, edgeTypeIndex) => {
-      const edgePath = `${path}.edgeTypes[${edgeTypeIndex}]`;
-      if (!edgeType.value || !KEBAB_CASE2.test(edgeType.value)) {
-        issues.push(
-          issue2(
-            "INVALID_ONTOLOGY_EDGE_VALUE",
-            "edge extension value must be kebab-case",
-            `${edgePath}.value`,
-            "ontology-extension"
-          )
-        );
-      } else if (edgeTypeValues.has(edgeType.value)) {
-        issues.push(
-          issue2(
-            "DUPLICATE_ONTOLOGY_EDGE_VALUE",
-            `Duplicate edge extension value "${edgeType.value}"`,
-            `${edgePath}.value`,
-            "ontology-extension"
-          )
-        );
-      } else {
-        edgeTypeValues.add(edgeType.value);
-      }
-      if (!edgeType.label) {
-        issues.push(
-          issue2(
-            "MISSING_ONTOLOGY_EDGE_LABEL",
-            "edge extension label is required",
-            `${edgePath}.label`,
-            "ontology-extension"
-          )
-        );
-      }
-      if (edgeType.constraintSeverity && !ONTOLOGY_CONSTRAINT_SEVERITIES.has(edgeType.constraintSeverity)) {
-        issues.push(
-          issue2(
-            "INVALID_ONTOLOGY_EDGE_SEVERITY",
-            `Unsupported constraint severity "${edgeType.constraintSeverity}"`,
-            `${edgePath}.constraintSeverity`,
-            "ontology-extension"
-          )
-        );
+    extension.edgeTypes?.forEach(
+      (edgeType, edgeTypeIndex) => {
+        const edgePath = `${path}.edgeTypes[${edgeTypeIndex}]`;
+        if (!edgeType.value || !KEBAB_CASE2.test(edgeType.value)) {
+          issues.push(
+            issue2(
+              "INVALID_ONTOLOGY_EDGE_VALUE",
+              "edge extension value must be kebab-case",
+              `${edgePath}.value`,
+              "ontology-extension"
+            )
+          );
+        } else if (edgeTypeValues.has(edgeType.value)) {
+          issues.push(
+            issue2(
+              "DUPLICATE_ONTOLOGY_EDGE_VALUE",
+              `Duplicate edge extension value "${edgeType.value}"`,
+              `${edgePath}.value`,
+              "ontology-extension"
+            )
+          );
+        } else {
+          edgeTypeValues.add(edgeType.value);
+        }
+        if (!edgeType.label) {
+          issues.push(
+            issue2(
+              "MISSING_ONTOLOGY_EDGE_LABEL",
+              "edge extension label is required",
+              `${edgePath}.label`,
+              "ontology-extension"
+            )
+          );
+        }
+        if (edgeType.constraintSeverity && !ONTOLOGY_CONSTRAINT_SEVERITIES.has(edgeType.constraintSeverity)) {
+          issues.push(
+            issue2(
+              "INVALID_ONTOLOGY_EDGE_SEVERITY",
+              `Unsupported constraint severity "${edgeType.constraintSeverity}"`,
+              `${edgePath}.constraintSeverity`,
+              "ontology-extension"
+            )
+          );
+        }
       }
-    });
+    );
   });
   return issues;
 }
@@ -1621,7 +1660,7 @@ function scanLegacyPublicKeys(value, path = "") {
     });
     return issues;
   }
-  if (!isPlainObject(value)) {
+  if (!isPlainObject2(value)) {
     return issues;
   }
   Object.entries(value).forEach(([key, entryValue]) => {
@@ -1720,7 +1759,7 @@ function validateDomainPackAuthoringManifest(manifest) {
   );
 }
 function validateDomainPackAuthoringManifestSource(source, format) {
-  const detectedFormat = detectDomainPackManifestFormat(source, format);
+  const detectedFormat = detectDomainPackManifestFormat2(source, format);
   try {
     const manifest = parseDomainPackAuthoringManifest(source, detectedFormat);
     return evaluateDomainPackAuthoringManifest(manifest, detectedFormat);
@@ -1870,27 +1909,45 @@ function createDomainPackAuthoringTools() {
     additionalProperties: false
   };
   return {
-    validate: {
+    validate: asToolDefinition({
       name: AUTHORING_TOOL_NAMES.validate,
       description: "Validate a domain pack authoring manifest and return structural, lineage, terminology, and extension issues.",
       inputSchema,
       execute: (args) => validateDomainPackAuthoringManifestSource(args.manifestText, args.format)
-    },
-    preview: {
+    }),
+    preview: asToolDefinition({
       name: AUTHORING_TOOL_NAMES.preview,
       description: "Preview a domain pack manifest with canonical JSON/YAML renderings, runtime targets, and publication readiness.",
       inputSchema,
       execute: (args) => previewDomainPackAuthoringManifestSource(args.manifestText, args.format)
-    },
-    publish: {
+    }),
+    publish: asToolDefinition({
       name: AUTHORING_TOOL_NAMES.publish,
       description: "Build a publication-ready domain pack artifact when validation passes, including remix/fork lineage metadata.",
       inputSchema,
       execute: (args) => publishDomainPackAuthoringManifestSource(args.manifestText, args.format)
-    }
+    })
   };
 }
+var domainPackAuthoringValidation = {
+  validateDomainPackAuthoringManifest,
+  validateDomainPackAuthoringManifestSource,
+  previewDomainPackAuthoringManifest,
+  previewDomainPackAuthoringManifestSource,
+  publishDomainPackAuthoringManifest,
+  publishDomainPackAuthoringManifestSource,
+  createDomainPackAuthoringTools
+};
+
+// src/domain-pack/authoring.ts
+var validateDomainPackAuthoringManifest2 = domainPackAuthoringValidation.validateDomainPackAuthoringManifest;
+var validateDomainPackAuthoringManifestSource2 = domainPackAuthoringValidation.validateDomainPackAuthoringManifestSource;
+var previewDomainPackAuthoringManifest2 = domainPackAuthoringValidation.previewDomainPackAuthoringManifest;
+var previewDomainPackAuthoringManifestSource2 = domainPackAuthoringValidation.previewDomainPackAuthoringManifestSource;
+var publishDomainPackAuthoringManifest2 = domainPackAuthoringValidation.publishDomainPackAuthoringManifest;
+var publishDomainPackAuthoringManifestSource2 = domainPackAuthoringValidation.publishDomainPackAuthoringManifestSource;
+var createDomainPackAuthoringTools2 = domainPackAuthoringValidation.createDomainPackAuthoringTools;
 
-export { createDomainPackAuthoringTools, defineDomainPackAuthoringManifest, parseDomainPackAuthoringManifest, previewDomainPackAuthoringManifest, previewDomainPackAuthoringManifestSource, publishDomainPackAuthoringManifest, publishDomainPackAuthoringManifestSource, serializeDomainPackAuthoringManifest, validateDomainPackAuthoringManifest, validateDomainPackAuthoringManifestSource };
+export { createDomainPackAuthoringTools2 as createDomainPackAuthoringTools, defineDomainPackAuthoringManifest, parseDomainPackAuthoringManifest, previewDomainPackAuthoringManifest2 as previewDomainPackAuthoringManifest, previewDomainPackAuthoringManifestSource2 as previewDomainPackAuthoringManifestSource, publishDomainPackAuthoringManifest2 as publishDomainPackAuthoringManifest, publishDomainPackAuthoringManifestSource2 as publishDomainPackAuthoringManifestSource, serializeDomainPackAuthoringManifest, validateDomainPackAuthoringManifest2 as validateDomainPackAuthoringManifest, validateDomainPackAuthoringManifestSource2 as validateDomainPackAuthoringManifestSource };
 //# sourceMappingURL=authoring.js.map
 //# sourceMappingURL=authoring.js.map