@lucern/pack-host 0.1.0-alpha.2

package/dist/domain-pack.js

@@ -0,0 +1,3813 @@
+// src/domain-pack/contracts.ts
+function dedupeStrings(values) {
+  return Array.from(
+    new Set(values.map((v) => v.trim()).filter((v) => v.length > 0))
+  );
+}
+function normalizeRuntimeTargets(values) {
+  return values ? dedupeStrings(values) : void 0;
+}
+function normalizeOntologyBinding(binding) {
+  return {
+    ...binding,
+    requiredEntityTypes: binding.requiredEntityTypes ? dedupeStrings(binding.requiredEntityTypes) : void 0,
+    requiredEdgeTypes: binding.requiredEdgeTypes ? dedupeStrings(binding.requiredEdgeTypes) : void 0
+  };
+}
+function normalizeOperatingSystem(layer) {
+  if (!layer) {
+    return;
+  }
+  return {
+    prompts: layer.prompts?.map((prompt) => ({
+      ...prompt,
+      runtimeTargets: normalizeRuntimeTargets(prompt.runtimeTargets)
+    })),
+    tools: layer.tools?.map((tool) => ({
+      ...tool,
+      runtimeTargets: normalizeRuntimeTargets(tool.runtimeTargets)
+    })),
+    setupAssets: layer.setupAssets?.map((asset) => ({
+      ...asset,
+      runtimeTargets: normalizeRuntimeTargets(asset.runtimeTargets)
+    })),
+    topicTemplates: layer.topicTemplates,
+    installProfiles: layer.installProfiles?.map((profile) => ({
+      ...profile,
+      promptIds: dedupeStrings(profile.promptIds),
+      toolIds: dedupeStrings(profile.toolIds),
+      assetIds: dedupeStrings(profile.assetIds),
+      defaultTopicSlugs: dedupeStrings(profile.defaultTopicSlugs)
+    }))
+  };
+}
+function defineDomainPack(input) {
+  return {
+    ...input,
+    ontologyBindings: input.ontologyBindings.map(normalizeOntologyBinding),
+    appPackKeys: input.appPackKeys ? dedupeStrings(input.appPackKeys) : void 0,
+    operatingSystem: normalizeOperatingSystem(input.operatingSystem),
+    workflows: input.workflows.map((w) => ({
+      ...w,
+      requiredArtifacts: dedupeStrings(w.requiredArtifacts),
+      gateCheckpoints: dedupeStrings(w.gateCheckpoints),
+      steps: w.steps.map((s) => ({
+        ...s,
+        requiredRoles: dedupeStrings(s.requiredRoles),
+        produces: s.produces ? dedupeStrings(s.produces) : void 0
+      }))
+    }))
+  };
+}
+
+// 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(
+          "INVALID_SHAPING_CONDITION",
+          `${label} must not contain empty strings`,
+          `${path}[${index}]`
+        )
+      ];
+    }
+    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(
+          "INVALID_RUNTIME_TARGET",
+          `Unsupported runtime target "${value}"`,
+          `${path}[${index}]`
+        )
+      );
+    }
+  }
+  return issues;
+}
+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`
+      )
+    );
+  }
+  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 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`)
+    );
+  }
+  if (!tool.entrypoint?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOOL_ENTRYPOINT",
+        "tool binding requires entrypoint",
+        `${path}.entrypoint`
+      )
+    );
+  }
+  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(
+        "MISSING_SETUP_ASSET_ID",
+        "setup asset requires assetId",
+        `${path}.assetId`
+      )
+    );
+  }
+  if (!asset.path?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_SETUP_ASSET_PATH",
+        "setup asset requires path",
+        `${path}.path`
+      )
+    );
+  }
+  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_SHAPING_TEMPLATE_ID",
+        "question template requires templateId",
+        `${path}.templateId`
+      )
+    );
+  }
+  if (!template.template?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_SHAPING_TEMPLATE",
+        "question template requires template text",
+        `${path}.template`
+      )
+    );
+  }
+  if (!SHAPING_QUESTION_TYPES.has(template.questionType)) {
+    issues.push(
+      issue(
+        "INVALID_SHAPING_QUESTION_TYPE",
+        `Unsupported questionType "${template.questionType}"`,
+        `${path}.questionType`
+      )
+    );
+  }
+  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 (!template.title?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TASK_GENERATOR_TITLE",
+        "task template requires title",
+        `${path}.title`
+      )
+    );
+  }
+  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}]`
+        )
+      );
+    }
+  }
+  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(
+        issue(
+          "INVALID_FRAMEWORK_HOOK_QUESTION_TYPE",
+          `Unsupported whenQuestionTypes value "${questionType}"`,
+          `${path}.whenQuestionTypes[${questionTypeIndex}]`
+        )
+      );
+    }
+  }
+  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(
+        issue(
+          "UNKNOWN_PROMPT_REF",
+          `install profile references unknown prompt "${promptId}"`,
+          `${path}.promptIds[${promptIndex}]`
+        )
+      );
+    }
+  }
+  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}]`
+        )
+      );
+    }
+  }
+  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}]`
+        )
+      );
+    }
+  }
+  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 issues;
+}
+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 issues;
+}
+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"
+      )
+    );
+  }
+  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(
+      issue(
+        "INVALID_VERSION",
+        `version "${pack.version}" must be valid semver`,
+        "version"
+      )
+    );
+  }
+  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`
+          )
+        );
+      }
+      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(
+      issue(
+        "MISSING_TOPIC_ROOTS",
+        "At least one topicRoot is required",
+        "topicRoots"
+      )
+    );
+  } else {
+    issues.push(
+      ...checkDuplicateIds(
+        pack.topicRoots,
+        "slug",
+        "topicRoots"
+      )
+    );
+  }
+  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 {
+    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 (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`
+            )
+          );
+        }
+      }
+      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`
+                )
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  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 {
+    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 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" };
+  }
+  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;
+  }
+  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 emptyCounts();
+  }
+  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 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)])
+    );
+  }
+  return value;
+}
+function escapeYamlString(value) {
+  return JSON.stringify(value);
+}
+function toYamlScalar(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return String(value);
+  }
+  return escapeYamlString(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)}`];
+    });
+  }
+  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 [`${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, "'");
+    }
+    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}`);
+  }
+  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);
+  }
+  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;
+  }
+  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;
+  }
+  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
+  });
+}
+function validateFrameworks(frameworks) {
+  if (!frameworks) {
+    return [];
+  }
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  frameworks.forEach((framework, index) => {
+    const path = `frameworks[${index}]`;
+    if (!framework.frameworkId) {
+      issues.push(
+        issue2(
+          "MISSING_FRAMEWORK_ID",
+          "frameworkId is required",
+          `${path}.frameworkId`,
+          "framework"
+        )
+      );
+    } else if (!KEBAB_CASE2.test(framework.frameworkId)) {
+      issues.push(
+        issue2(
+          "INVALID_FRAMEWORK_ID",
+          `frameworkId "${framework.frameworkId}" must be kebab-case`,
+          `${path}.frameworkId`,
+          "framework"
+        )
+      );
+    } else if (seen.has(framework.frameworkId)) {
+      issues.push(
+        issue2(
+          "DUPLICATE_FRAMEWORK_ID",
+          `Duplicate frameworkId "${framework.frameworkId}"`,
+          `${path}.frameworkId`,
+          "framework"
+        )
+      );
+    } else {
+      seen.add(framework.frameworkId);
+    }
+    if (!framework.version) {
+      issues.push(
+        issue2(
+          "MISSING_FRAMEWORK_VERSION",
+          "version is required",
+          `${path}.version`,
+          "framework"
+        )
+      );
+    } else if (!SEMVER2.test(framework.version)) {
+      issues.push(
+        issue2(
+          "INVALID_FRAMEWORK_VERSION",
+          `framework version "${framework.version}" must be valid semver`,
+          `${path}.version`,
+          "framework"
+        )
+      );
+    }
+  });
+  return issues;
+}
+function validateSchemaExtensions(extensions) {
+  if (!extensions) {
+    return [];
+  }
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  extensions.forEach((extension, index) => {
+    const path = `schemaExtensions[${index}]`;
+    if (!extension.extensionId) {
+      issues.push(
+        issue2(
+          "MISSING_SCHEMA_EXTENSION_ID",
+          "extensionId is required",
+          `${path}.extensionId`,
+          "schema-extension"
+        )
+      );
+    } else if (!KEBAB_CASE2.test(extension.extensionId)) {
+      issues.push(
+        issue2(
+          "INVALID_SCHEMA_EXTENSION_ID",
+          `extensionId "${extension.extensionId}" must be kebab-case`,
+          `${path}.extensionId`,
+          "schema-extension"
+        )
+      );
+    } else if (seen.has(extension.extensionId)) {
+      issues.push(
+        issue2(
+          "DUPLICATE_SCHEMA_EXTENSION_ID",
+          `Duplicate schema extension "${extension.extensionId}"`,
+          `${path}.extensionId`,
+          "schema-extension"
+        )
+      );
+    } else {
+      seen.add(extension.extensionId);
+    }
+    if (!SCHEMA_EXTENSION_TARGETS.has(extension.target)) {
+      issues.push(
+        issue2(
+          "INVALID_SCHEMA_EXTENSION_TARGET",
+          `Unsupported schema extension target "${extension.target}"`,
+          `${path}.target`,
+          "schema-extension"
+        )
+      );
+    }
+    if (!extension.description) {
+      issues.push(
+        issue2(
+          "MISSING_SCHEMA_EXTENSION_DESCRIPTION",
+          "description is required",
+          `${path}.description`,
+          "schema-extension"
+        )
+      );
+    }
+    if (!SEMVER2.test(extension.version)) {
+      issues.push(
+        issue2(
+          "INVALID_SCHEMA_EXTENSION_VERSION",
+          `schema extension version "${extension.version}" must be valid semver`,
+          `${path}.version`,
+          "schema-extension"
+        )
+      );
+    }
+    if (!isPlainObject(extension.schema)) {
+      issues.push(
+        issue2(
+          "INVALID_SCHEMA_EXTENSION_SCHEMA",
+          "schema extension schema must be a plain object",
+          `${path}.schema`,
+          "schema-extension"
+        )
+      );
+    }
+  });
+  return issues;
+}
+function validateOntologyExtensions(extensions) {
+  if (!extensions) {
+    return [];
+  }
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  extensions.forEach((extension, index) => {
+    const path = `ontologyExtensions[${index}]`;
+    if (!extension.extensionId) {
+      issues.push(
+        issue2(
+          "MISSING_ONTOLOGY_EXTENSION_ID",
+          "extensionId is required",
+          `${path}.extensionId`,
+          "ontology-extension"
+        )
+      );
+    } else if (!KEBAB_CASE2.test(extension.extensionId)) {
+      issues.push(
+        issue2(
+          "INVALID_ONTOLOGY_EXTENSION_ID",
+          `extensionId "${extension.extensionId}" must be kebab-case`,
+          `${path}.extensionId`,
+          "ontology-extension"
+        )
+      );
+    } else if (seen.has(extension.extensionId)) {
+      issues.push(
+        issue2(
+          "DUPLICATE_ONTOLOGY_EXTENSION_ID",
+          `Duplicate ontology extension "${extension.extensionId}"`,
+          `${path}.extensionId`,
+          "ontology-extension"
+        )
+      );
+    } else {
+      seen.add(extension.extensionId);
+    }
+    if (!extension.ontologyId) {
+      issues.push(
+        issue2(
+          "MISSING_ONTOLOGY_EXTENSION_TARGET",
+          "ontologyId is required",
+          `${path}.ontologyId`,
+          "ontology-extension"
+        )
+      );
+    }
+    if (!extension.baseVersionConstraint) {
+      issues.push(
+        issue2(
+          "MISSING_ONTOLOGY_BASE_VERSION",
+          "baseVersionConstraint is required",
+          `${path}.baseVersionConstraint`,
+          "ontology-extension"
+        )
+      );
+    }
+    if (extension.additiveOnly !== true) {
+      issues.push(
+        issue2(
+          "NON_MONOTONIC_ONTOLOGY_EXTENSION",
+          "ontology extensions must set additiveOnly=true",
+          `${path}.additiveOnly`,
+          "ontology-extension"
+        )
+      );
+    }
+    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"
+          )
+        );
+      }
+    });
+    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"
+          )
+        );
+      }
+    });
+  });
+  return issues;
+}
+function validateLineage(lineage, packId) {
+  const issues = [];
+  if (!LINEAGE_MODES.has(lineage.mode)) {
+    issues.push(
+      issue2(
+        "INVALID_LINEAGE_MODE",
+        `Unsupported lineage mode "${lineage.mode}"`,
+        "lineage.mode",
+        "lineage"
+      )
+    );
+    return issues;
+  }
+  if (lineage.mode === "root") {
+    if (lineage.parentPackId || lineage.parentVersion || lineage.supersedesPackId) {
+      issues.push(
+        issue2(
+          "ROOT_LINEAGE_HAS_PARENT",
+          "root lineage cannot declare parent or supersedes metadata",
+          "lineage",
+          "lineage"
+        )
+      );
+    }
+    return issues;
+  }
+  if (!lineage.parentPackId) {
+    issues.push(
+      issue2(
+        "MISSING_LINEAGE_PARENT_PACK",
+        "parentPackId is required for remix or fork lineage",
+        "lineage.parentPackId",
+        "lineage"
+      )
+    );
+  } else if (!KEBAB_CASE2.test(lineage.parentPackId)) {
+    issues.push(
+      issue2(
+        "INVALID_LINEAGE_PARENT_PACK",
+        `parentPackId "${lineage.parentPackId}" must be kebab-case`,
+        "lineage.parentPackId",
+        "lineage"
+      )
+    );
+  }
+  if (!lineage.parentVersion) {
+    issues.push(
+      issue2(
+        "MISSING_LINEAGE_PARENT_VERSION",
+        "parentVersion is required for remix or fork lineage",
+        "lineage.parentVersion",
+        "lineage"
+      )
+    );
+  } else if (!SEMVER2.test(lineage.parentVersion)) {
+    issues.push(
+      issue2(
+        "INVALID_LINEAGE_PARENT_VERSION",
+        `parentVersion "${lineage.parentVersion}" must be valid semver`,
+        "lineage.parentVersion",
+        "lineage"
+      )
+    );
+  }
+  if (lineage.parentPackId && lineage.parentPackId === packId && lineage.parentVersion === void 0) {
+    issues.push(
+      issue2(
+        "SELF_REFERENTIAL_LINEAGE",
+        "lineage parentPackId cannot equal the child packId without an explicit parentVersion",
+        "lineage.parentPackId",
+        "lineage"
+      )
+    );
+  }
+  if (lineage.mode === "remix" && lineage.supersedesPackId) {
+    issues.push(
+      issue2(
+        "REMIX_LINEAGE_SUPERSEDES",
+        "remix lineage cannot declare supersedesPackId",
+        "lineage.supersedesPackId",
+        "lineage"
+      )
+    );
+  }
+  if (lineage.mode === "fork") {
+    if (!lineage.supersedesPackId) {
+      issues.push(
+        issue2(
+          "MISSING_SUPERSEDES_PACK",
+          "fork lineage requires supersedesPackId to model the supersedes edge",
+          "lineage.supersedesPackId",
+          "lineage"
+        )
+      );
+    } else if (!KEBAB_CASE2.test(lineage.supersedesPackId)) {
+      issues.push(
+        issue2(
+          "INVALID_SUPERSEDES_PACK",
+          `supersedesPackId "${lineage.supersedesPackId}" must be kebab-case`,
+          "lineage.supersedesPackId",
+          "lineage"
+        )
+      );
+    }
+  }
+  return issues;
+}
+function scanLegacyPublicKeys(value, path = "") {
+  const issues = [];
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => {
+      issues.push(...scanLegacyPublicKeys(entry, `${path}[${index}]`));
+    });
+    return issues;
+  }
+  if (!isPlainObject(value)) {
+    return issues;
+  }
+  Object.entries(value).forEach(([key, entryValue]) => {
+    const nextPath = path ? `${path}.${key}` : key;
+    if (LEGACY_PUBLIC_KEYS.has(key)) {
+      issues.push(
+        issue2(
+          "LEGACY_PUBLIC_TERM",
+          `Public manifest field "${key}" uses legacy terminology; expose canonical topic/worktree terms instead.`,
+          nextPath,
+          "terminology"
+        )
+      );
+    }
+    issues.push(...scanLegacyPublicKeys(entryValue, nextPath));
+  });
+  return issues;
+}
+function createManifestDigest(manifest) {
+  const data = serializeDomainPackAuthoringManifest(manifest, "json");
+  let h1 = 2166136261 | 0;
+  let h2 = 2166136261 | 0;
+  for (let i = 0; i < data.length; i++) {
+    const c = data.charCodeAt(i);
+    h1 = Math.imul(h1 ^ c, 16777619);
+    h2 = Math.imul(h2 ^ (c >>> 4 | c << 4), 16777619);
+  }
+  return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
+}
+function evaluateDomainPackAuthoringManifest(manifest, format = null) {
+  const issues = [];
+  if (manifest.kind !== DOMAIN_PACK_MANIFEST_KIND) {
+    issues.push(
+      issue2(
+        "INVALID_MANIFEST_KIND",
+        `kind must be "${DOMAIN_PACK_MANIFEST_KIND}"`,
+        "kind",
+        "manifest"
+      )
+    );
+  }
+  if (!SEMVER2.test(manifest.manifestVersion)) {
+    issues.push(
+      issue2(
+        "INVALID_MANIFEST_VERSION",
+        `manifestVersion "${manifest.manifestVersion}" must be valid semver`,
+        "manifestVersion",
+        "manifest"
+      )
+    );
+  }
+  issues.push(...validateFrameworks(manifest.frameworks));
+  issues.push(...validateSchemaExtensions(manifest.schemaExtensions));
+  issues.push(...validateOntologyExtensions(manifest.ontologyExtensions));
+  issues.push(...validateLineage(manifest.lineage, manifest.pack.packId));
+  issues.push(...scanLegacyPublicKeys(manifest));
+  const packValidation = validateDomainPack(manifest.pack);
+  issues.push(
+    ...packValidation.issues.map((packIssue) => ({
+      ...packIssue,
+      path: `pack.${packIssue.path}`,
+      source: "pack"
+    }))
+  );
+  return {
+    valid: issues.every((currentIssue) => currentIssue.severity !== "error"),
+    format,
+    manifest,
+    manifestDigest: createManifestDigest(manifest),
+    issues,
+    counts: countManifestArtifacts(manifest)
+  };
+}
+function parseFailureResult(error, format) {
+  return {
+    valid: false,
+    format,
+    manifest: null,
+    manifestDigest: null,
+    issues: [
+      issue2(
+        "PARSE_ERROR",
+        error instanceof Error ? error.message : String(error),
+        "manifest",
+        "parse"
+      )
+    ],
+    counts: emptyCounts()
+  };
+}
+function validateDomainPackAuthoringManifest(manifest) {
+  return evaluateDomainPackAuthoringManifest(
+    defineDomainPackAuthoringManifest(
+      manifest
+    )
+  );
+}
+function validateDomainPackAuthoringManifestSource(source, format) {
+  const detectedFormat = detectDomainPackManifestFormat(source, format);
+  try {
+    const manifest = parseDomainPackAuthoringManifest(source, detectedFormat);
+    return evaluateDomainPackAuthoringManifest(manifest, detectedFormat);
+  } catch (error) {
+    return parseFailureResult(error, detectedFormat);
+  }
+}
+function collectRuntimeTargets(manifest) {
+  if (!manifest) {
+    return [];
+  }
+  const targets = /* @__PURE__ */ new Set();
+  manifest.frameworks?.forEach(
+    (framework) => framework.runtimeTargets?.forEach((target) => targets.add(target))
+  );
+  manifest.pack.operatingSystem?.prompts?.forEach(
+    (prompt) => prompt.runtimeTargets?.forEach((target) => targets.add(target))
+  );
+  manifest.pack.operatingSystem?.tools?.forEach(
+    (tool) => tool.runtimeTargets?.forEach((target) => targets.add(target))
+  );
+  manifest.pack.operatingSystem?.setupAssets?.forEach(
+    (asset) => asset.runtimeTargets?.forEach((target) => targets.add(target))
+  );
+  manifest.pack.operatingSystem?.installProfiles?.forEach(
+    (profile) => targets.add(profile.runtimeTarget)
+  );
+  return Array.from(targets).sort();
+}
+function describeLineage(lineage) {
+  if (!lineage) {
+    return null;
+  }
+  if (lineage.mode === "root") {
+    return "Root pack with no parent lineage.";
+  }
+  if (lineage.mode === "remix") {
+    return `Remix of ${lineage.parentPackId}@${lineage.parentVersion}.`;
+  }
+  return `Fork of ${lineage.parentPackId}@${lineage.parentVersion} that supersedes ${lineage.supersedesPackId}.`;
+}
+function previewDomainPackAuthoringManifest(manifest) {
+  const validation = validateDomainPackAuthoringManifest(manifest);
+  return {
+    ...validation,
+    readyToPublish: validation.valid,
+    canonicalJson: validation.manifest ? serializeDomainPackAuthoringManifest(validation.manifest, "json") : null,
+    canonicalYaml: validation.manifest ? serializeDomainPackAuthoringManifest(validation.manifest, "yaml") : null,
+    lineageSummary: describeLineage(validation.manifest?.lineage ?? null),
+    requiredRuntimeTargets: collectRuntimeTargets(validation.manifest)
+  };
+}
+function previewDomainPackAuthoringManifestSource(source, format) {
+  const validation = validateDomainPackAuthoringManifestSource(source, format);
+  return {
+    ...validation,
+    readyToPublish: validation.valid,
+    canonicalJson: validation.manifest ? serializeDomainPackAuthoringManifest(validation.manifest, "json") : null,
+    canonicalYaml: validation.manifest ? serializeDomainPackAuthoringManifest(validation.manifest, "yaml") : null,
+    lineageSummary: describeLineage(validation.manifest?.lineage ?? null),
+    requiredRuntimeTargets: collectRuntimeTargets(validation.manifest)
+  };
+}
+function buildLineageEdge(manifest) {
+  const { lineage, pack } = manifest;
+  if (lineage.mode === "root") {
+    return null;
+  }
+  if (lineage.mode === "remix") {
+    return {
+      edgeType: "remixed_from",
+      childPackId: pack.packId,
+      parentPackId: lineage.parentPackId,
+      parentVersion: lineage.parentVersion
+    };
+  }
+  return {
+    edgeType: "supersedes",
+    childPackId: pack.packId,
+    parentPackId: lineage.supersedesPackId,
+    parentVersion: lineage.parentVersion
+  };
+}
+function publishDomainPackAuthoringManifest(manifest) {
+  const preview = previewDomainPackAuthoringManifest(manifest);
+  if (!preview.readyToPublish || !preview.manifest || !preview.manifestDigest) {
+    return {
+      published: false,
+      preview,
+      publication: null
+    };
+  }
+  return {
+    published: true,
+    preview,
+    publication: {
+      publicationId: `${preview.manifest.pack.packId}@${preview.manifest.pack.version}`,
+      packId: preview.manifest.pack.packId,
+      version: preview.manifest.pack.version,
+      manifestDigest: preview.manifestDigest,
+      manifest: preview.manifest,
+      lineageEdge: buildLineageEdge(preview.manifest),
+      canonicalJson: preview.canonicalJson,
+      canonicalYaml: preview.canonicalYaml
+    }
+  };
+}
+function publishDomainPackAuthoringManifestSource(source, format) {
+  const preview = previewDomainPackAuthoringManifestSource(source, format);
+  if (!preview.readyToPublish || !preview.manifest || !preview.manifestDigest) {
+    return {
+      published: false,
+      preview,
+      publication: null
+    };
+  }
+  return {
+    published: true,
+    preview,
+    publication: {
+      publicationId: `${preview.manifest.pack.packId}@${preview.manifest.pack.version}`,
+      packId: preview.manifest.pack.packId,
+      version: preview.manifest.pack.version,
+      manifestDigest: preview.manifestDigest,
+      manifest: preview.manifest,
+      lineageEdge: buildLineageEdge(preview.manifest),
+      canonicalJson: preview.canonicalJson,
+      canonicalYaml: preview.canonicalYaml
+    }
+  };
+}
+function createDomainPackAuthoringTools() {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      manifestText: {
+        type: "string",
+        description: "Domain pack manifest text in JSON or YAML form."
+      },
+      format: {
+        type: "string",
+        enum: ["json", "yaml"],
+        description: "Optional manifest format override."
+      }
+    },
+    required: ["manifestText"],
+    additionalProperties: false
+  };
+  return {
+    validate: {
+      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: {
+      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: {
+      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)
+    }
+  };
+}
+
+// src/domain-pack/ontology/software-entities-v1.ts
+var SOFTWARE_ENTITIES_V1 = {
+  ontologyId: "software-entities",
+  version: "1.0.0",
+  name: "Software Entities",
+  description: "Core software-delivery ontology for repositories, services, modules, changes, incidents, and agent-assisted engineering workflows.",
+  entityTypes: [
+    {
+      value: "repository",
+      label: "Repository",
+      description: "Source repository or monorepo boundary under active ownership."
+    },
+    {
+      value: "service",
+      label: "Service",
+      description: "Deployable service, application, or runtime surface."
+    },
+    {
+      value: "module",
+      label: "Module",
+      description: "Logical code module, package, or subsystem within a service."
+    },
+    {
+      value: "workflow",
+      label: "Workflow",
+      description: "Repeatable engineering workflow such as review, migration, or incident response."
+    },
+    {
+      value: "migration",
+      label: "Migration",
+      description: "Schema, API, or rollout change with sequencing and rollback concerns."
+    },
+    {
+      value: "incident",
+      label: "Incident",
+      description: "Operational incident, outage, or regression requiring triage and mitigation."
+    },
+    {
+      value: "decision_record",
+      label: "Decision Record",
+      description: "Architecture decision, rationale record, or precedent artifact."
+    },
+    {
+      value: "agent",
+      label: "Agent",
+      description: "Configured AI worker or assistant participating in engineering workflows."
+    }
+  ],
+  edgeTypes: [
+    {
+      value: "depends_on",
+      label: "Depends On",
+      description: "A repository, service, module, or workflow depends on another surface.",
+      sourceTypes: ["repository", "service", "module", "workflow", "migration"],
+      targetTypes: ["repository", "service", "module", "workflow", "migration"]
+    },
+    {
+      value: "owns",
+      label: "Owns",
+      description: "An agent or service owns a module, workflow, or decision record.",
+      sourceTypes: ["agent", "service"],
+      targetTypes: ["module", "workflow", "decision_record"]
+    },
+    {
+      value: "calls",
+      label: "Calls",
+      description: "A repository, service, or module invokes another service or module.",
+      sourceTypes: ["repository", "service", "module"],
+      targetTypes: ["service", "module"]
+    },
+    {
+      value: "blocks",
+      label: "Blocks",
+      description: "An incident, migration, or workflow blocks another engineering surface.",
+      sourceTypes: ["incident", "migration", "workflow"],
+      targetTypes: ["migration", "workflow", "service", "decision_record"]
+    },
+    {
+      value: "reviews",
+      label: "Reviews",
+      description: "An agent or workflow reviews a change, module, or migration.",
+      sourceTypes: ["agent", "workflow"],
+      targetTypes: ["module", "migration", "decision_record"]
+    },
+    {
+      value: "mitigates",
+      label: "Mitigates",
+      description: "A workflow or migration mitigates an incident or risky change.",
+      sourceTypes: ["workflow", "migration"],
+      targetTypes: ["incident", "service", "module"]
+    },
+    {
+      value: "supersedes",
+      label: "Supersedes",
+      description: "A newer decision record, migration, or workflow replaces an earlier one.",
+      sourceTypes: ["decision_record", "migration", "workflow"],
+      targetTypes: ["decision_record", "migration", "workflow"]
+    }
+  ]
+};
+
+// src/domain-pack/shaping.ts
+var QUESTION_PRIORITY_WEIGHT = {
+  critical: 0.12,
+  high: 0.08,
+  medium: 0.04,
+  low: 0.01
+};
+var TASK_PRIORITY_WEIGHT = {
+  urgent: 0.12,
+  high: 0.08,
+  medium: 0.04,
+  low: 0.01
+};
+function dedupeStrings3(values) {
+  if (!values || values.length === 0) {
+    return void 0;
+  }
+  const normalized = values.map((value) => value.trim()).filter(Boolean);
+  return normalized.length > 0 ? Array.from(new Set(normalized)) : void 0;
+}
+function toKebabCase(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeCondition(args) {
+  return {
+    ...dedupeStrings3(args.objectiveIncludes) ? { objectiveIncludes: dedupeStrings3(args.objectiveIncludes) } : {},
+    ...dedupeStrings3(args.questionTypes) ? { questionTypes: dedupeStrings3(args.questionTypes) } : {}
+  };
+}
+function normalizeQuestionType(questionType) {
+  return questionType === "scope" ? "clarification" : questionType;
+}
+function questionTemplateToContribution(packId, template) {
+  return {
+    sourcePackId: packId,
+    templateId: template.templateId,
+    questionType: normalizeQuestionType(template.questionType),
+    priority: template.priority,
+    priorityWeight: QUESTION_PRIORITY_WEIGHT[template.priority || "medium"],
+    template: template.template,
+    condition: normalizeCondition({
+      objectiveIncludes: template.whenObjectiveIncludes
+    })
+  };
+}
+function taskTemplateToContribution(packId, template) {
+  return {
+    sourcePackId: packId,
+    generatorId: template.templateId,
+    title: template.title,
+    description: template.description,
+    taskType: template.taskType,
+    priority: template.priority,
+    priorityWeight: TASK_PRIORITY_WEIGHT[template.priority || "medium"],
+    condition: normalizeCondition({
+      objectiveIncludes: template.whenObjectiveIncludes,
+      questionTypes: template.whenQuestionTypes
+    })
+  };
+}
+function frameworkHintToContribution(packId, hint) {
+  const hookId = `${packId}:${toKebabCase(hint.frameworkName || "framework")}`;
+  return {
+    sourcePackId: packId,
+    hookId,
+    frameworkName: hint.frameworkName,
+    boost: hint.boost || 0,
+    reason: hint.reason,
+    priorityWeight: Math.max(0.02, hint.boost || 0),
+    condition: normalizeCondition({
+      objectiveIncludes: hint.whenObjectiveIncludes,
+      questionTypes: hint.whenQuestionTypes
+    })
+  };
+}
+function issue3(code, message, path, severity = "error") {
+  return { code, message, path, severity };
+}
+function checkDuplicateIds2(items, idField, path) {
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const id = item[idField];
+    if (!id) {
+      continue;
+    }
+    if (seen.has(id)) {
+      issues.push(
+        issue3("DUPLICATE_ID", `Duplicate ${idField} "${id}"`, `${path}.${idField}`)
+      );
+    }
+    seen.add(id);
+  }
+  return issues;
+}
+function formatRegistrationIssues(packId, issues) {
+  return `Invalid shaping contribution registration for ${packId}: ${issues.map((item) => `${item.code} at ${item.path}`).join("; ")}`;
+}
+function buildShapingContribution(pack) {
+  const inquiryShaping = pack.inquiryShaping || {};
+  return {
+    packId: pack.packId,
+    questionTemplates: (inquiryShaping.questionTemplates || []).map(
+      (template) => questionTemplateToContribution(pack.packId, template)
+    ),
+    taskGenerators: (inquiryShaping.taskTemplates || []).map(
+      (template) => taskTemplateToContribution(pack.packId, template)
+    ),
+    frameworkHooks: (inquiryShaping.frameworkHints || []).map(
+      (hint) => frameworkHintToContribution(pack.packId, hint)
+    )
+  };
+}
+function validateShapingContribution(contribution) {
+  const issues = [];
+  if (!contribution.packId?.trim()) {
+    issues.push(issue3("MISSING_PACK_ID", "packId is required", "packId"));
+  }
+  issues.push(
+    ...checkDuplicateIds2(
+      contribution.questionTemplates,
+      "templateId",
+      "questionTemplates"
+    )
+  );
+  issues.push(
+    ...checkDuplicateIds2(
+      contribution.taskGenerators,
+      "generatorId",
+      "taskGenerators"
+    )
+  );
+  issues.push(
+    ...checkDuplicateIds2(
+      contribution.frameworkHooks,
+      "hookId",
+      "frameworkHooks"
+    )
+  );
+  contribution.questionTemplates.forEach((template, index) => {
+    if (!template.templateId?.trim()) {
+      issues.push(
+        issue3(
+          "MISSING_TEMPLATE_ID",
+          "Question template requires templateId",
+          `questionTemplates[${index}].templateId`
+        )
+      );
+    }
+    if (!template.template?.trim()) {
+      issues.push(
+        issue3(
+          "MISSING_TEMPLATE",
+          "Question template requires template text",
+          `questionTemplates[${index}].template`
+        )
+      );
+    }
+  });
+  contribution.taskGenerators.forEach((generator, index) => {
+    if (!generator.generatorId?.trim()) {
+      issues.push(
+        issue3(
+          "MISSING_GENERATOR_ID",
+          "Task generator requires generatorId",
+          `taskGenerators[${index}].generatorId`
+        )
+      );
+    }
+    if (!generator.title?.trim()) {
+      issues.push(
+        issue3(
+          "MISSING_TASK_TITLE",
+          "Task generator requires title",
+          `taskGenerators[${index}].title`
+        )
+      );
+    }
+  });
+  contribution.frameworkHooks.forEach((hook, index) => {
+    if (!hook.frameworkName?.trim()) {
+      issues.push(
+        issue3(
+          "MISSING_FRAMEWORK_NAME",
+          "Framework hook requires frameworkName",
+          `frameworkHooks[${index}].frameworkName`
+        )
+      );
+    }
+    if (!Number.isFinite(hook.boost) || hook.boost < 0) {
+      issues.push(
+        issue3(
+          "INVALID_FRAMEWORK_BOOST",
+          "Framework hook boost must be a non-negative number",
+          `frameworkHooks[${index}].boost`
+        )
+      );
+    }
+  });
+  return {
+    valid: issues.every((item) => item.severity !== "error"),
+    issues
+  };
+}
+function createShapingContributionRegistry(packs = []) {
+  const registry = /* @__PURE__ */ new Map();
+  const register = (pack) => {
+    if (registry.has(pack.packId)) {
+      throw new Error(
+        `Duplicate shaping contribution registration for ${pack.packId}`
+      );
+    }
+    const packValidation = validateDomainPack(pack);
+    if (!packValidation.valid) {
+      throw new Error(formatRegistrationIssues(pack.packId, packValidation.issues));
+    }
+    const contribution = buildShapingContribution(pack);
+    const contributionValidation = validateShapingContribution(contribution);
+    if (!contributionValidation.valid) {
+      throw new Error(
+        formatRegistrationIssues(pack.packId, contributionValidation.issues)
+      );
+    }
+    registry.set(pack.packId, contribution);
+    return contribution;
+  };
+  packs.forEach(register);
+  return {
+    register,
+    get(packId) {
+      return registry.get(packId) ?? null;
+    },
+    list() {
+      return Array.from(registry.keys());
+    }
+  };
+}
+
+// src/domain-pack/packs/developer-reasoning.ts
+var DEVELOPER_REASONING_PACK = defineDomainPack({
+  packId: "developer-reasoning",
+  name: "Developer Reasoning",
+  version: "1.0.0",
+  ontologyBindings: [
+    {
+      ontologyId: "software-entities",
+      versionConstraint: "^1.0.0",
+      required: true
+    }
+  ],
+  topicRoots: [
+    {
+      slug: "architecture",
+      name: "Architecture",
+      description: "System architecture decisions and trade-offs",
+      ontologyId: "software-entities"
+    },
+    {
+      slug: "implementation",
+      name: "Implementation",
+      description: "Active implementation work and worktrees",
+      ontologyId: "software-entities"
+    },
+    {
+      slug: "operations",
+      name: "Operations",
+      description: "Deployment, observability, and operational concerns"
+    }
+  ],
+  workflows: [
+    {
+      workflowId: "worktree-lifecycle",
+      name: "Worktree Lifecycle",
+      description: "Structured development cycle from scoping through implementation and review",
+      steps: [
+        {
+          stepId: "scope",
+          name: "Scope & Context",
+          description: "Read graph context, identify constraints and prior decisions",
+          requiredRoles: ["investigator"],
+          produces: ["scope-artifact"]
+        },
+        {
+          stepId: "plan",
+          name: "Plan",
+          description: "Design implementation approach informed by graph beliefs",
+          requiredRoles: ["investigator", "critic"],
+          produces: ["plan-artifact"],
+          gateId: "plan-reviewed"
+        },
+        {
+          stepId: "build",
+          name: "Build",
+          description: "Implement with in-flight graph writeback",
+          requiredRoles: ["implementer"],
+          produces: ["implementation-artifact"]
+        },
+        {
+          stepId: "review",
+          name: "Review",
+          description: "Validate implementation against plan, tests, and type safety",
+          requiredRoles: ["critic"],
+          produces: ["review-artifact"],
+          gateId: "review-passed"
+        }
+      ],
+      requiredArtifacts: ["scope-artifact", "implementation-artifact"],
+      gateCheckpoints: ["plan-reviewed", "review-passed"]
+    }
+  ],
+  gates: [
+    {
+      gateId: "plan-reviewed",
+      name: "Plan Reviewed",
+      description: "Implementation plan has been reviewed for feasibility",
+      criteria: [
+        {
+          criterionId: "constraints-checked",
+          description: "Plan respects high-credence beliefs (>= 0.90) as constraints",
+          metric: "constraint_violations",
+          threshold: 0,
+          operator: "eq"
+        },
+        {
+          criterionId: "scope-bounded",
+          description: "Plan stays within declared file and concern scope",
+          metric: "scope_bounded",
+          threshold: 1,
+          operator: "eq"
+        }
+      ],
+      severity: "blocking"
+    },
+    {
+      gateId: "review-passed",
+      name: "Review Passed",
+      description: "Implementation passes type checks, tests, and review",
+      criteria: [
+        {
+          criterionId: "types-clean",
+          description: "TypeScript check passes (npx tsc --noEmit)",
+          metric: "tsc_errors",
+          threshold: 0,
+          operator: "eq"
+        },
+        {
+          criterionId: "tests-passing",
+          description: "All relevant tests pass",
+          metric: "test_pass_ratio",
+          threshold: 1,
+          operator: "eq"
+        }
+      ],
+      severity: "blocking"
+    }
+  ],
+  artifacts: [
+    {
+      artifactId: "scope-artifact",
+      name: "Scope Context",
+      description: "Graph context summary \u2014 beliefs, questions, constraints informing this work",
+      stage: "scope",
+      contentSchema: {
+        type: "object",
+        properties: {
+          beliefs: { type: "array", items: { type: "string" } },
+          questions: { type: "array", items: { type: "string" } },
+          constraints: { type: "array", items: { type: "string" } }
+        },
+        required: ["beliefs", "constraints"]
+      },
+      requiredFields: ["beliefs", "constraints"]
+    },
+    {
+      artifactId: "plan-artifact",
+      name: "Implementation Plan",
+      description: "Files to create/modify, approach, and test strategy",
+      stage: "plan",
+      contentSchema: {
+        type: "object",
+        properties: {
+          files: { type: "array", items: { type: "string" } },
+          approach: { type: "string" },
+          testStrategy: { type: "string" }
+        },
+        required: ["files", "approach"]
+      },
+      requiredFields: ["files", "approach"]
+    },
+    {
+      artifactId: "implementation-artifact",
+      name: "Implementation Summary",
+      description: "What was built, files changed, decisions made",
+      stage: "build",
+      contentSchema: {
+        type: "object",
+        properties: {
+          filesChanged: { type: "array", items: { type: "string" } },
+          decisions: { type: "array", items: { type: "string" } },
+          deferredWork: { type: "array", items: { type: "string" } }
+        },
+        required: ["filesChanged"]
+      },
+      requiredFields: ["filesChanged"]
+    },
+    {
+      artifactId: "review-artifact",
+      name: "Review Summary",
+      description: "Review findings, type check results, test results",
+      stage: "review",
+      contentSchema: {
+        type: "object",
+        properties: {
+          verdict: { type: "string", enum: ["approve", "request-changes"] },
+          findings: { type: "array", items: { type: "string" } },
+          testsPassing: { type: "boolean" },
+          typesClean: { type: "boolean" }
+        },
+        required: ["verdict", "testsPassing", "typesClean"]
+      },
+      requiredFields: ["verdict", "testsPassing", "typesClean"]
+    }
+  ],
+  roles: [
+    {
+      roleId: "investigator",
+      name: "Investigator",
+      description: "Reads graph context and identifies relevant prior knowledge",
+      perspective: "Context-aware, evidence-driven scoping",
+      optimizesFor: "thoroughness of context retrieval and constraint identification",
+      mayBlock: false
+    },
+    {
+      roleId: "implementer",
+      name: "Implementer",
+      description: "Writes code and records decisions in the graph",
+      perspective: "Pragmatic, focused on working code within constraints",
+      optimizesFor: "correctness and simplicity",
+      mayBlock: false
+    },
+    {
+      roleId: "critic",
+      name: "Critic",
+      description: "Challenges assumptions, finds edge cases, and surfaces risks",
+      perspective: "Skeptical, detail-oriented, adversarial testing",
+      optimizesFor: "identifying weaknesses before they reach production",
+      mayBlock: true
+      // Epistemic Invariant #13
+    }
+  ],
+  inquiryShaping: {
+    questionTemplates: [
+      {
+        templateId: "developer-boundary-falsifier",
+        questionType: "falsification",
+        priority: "high",
+        template: "Which interface, contract, or boundary would fail first if {{objective}} is wrong?",
+        whenObjectiveIncludes: [
+          "build",
+          "implement",
+          "refactor",
+          "integrate",
+          "algorithm",
+          "handler",
+          "workflow"
+        ]
+      },
+      {
+        templateId: "developer-regression-counterfactual",
+        questionType: "counterfactual",
+        priority: "high",
+        template: "What existing behavior or verification path would regress if {{hypothesis}} is false?",
+        whenObjectiveIncludes: ["build", "implement", "add", "extend", "support"]
+      }
+    ],
+    taskTemplates: [
+      {
+        templateId: "developer-contract-audit",
+        title: "Audit adjacent contracts and invariants for {{objective}}",
+        description: "Inspect the existing MCP, schema, and worktree contracts that constrain {{objective}} before changing runtime behavior.",
+        taskType: "analysis",
+        priority: "high",
+        whenObjectiveIncludes: ["build", "implement", "extend", "support"]
+      },
+      {
+        templateId: "developer-verification-pass",
+        title: "Run focused verification for {{objective}}",
+        description: "Add or update targeted tests and type-safety checks that would fail if {{hypothesis}} is wrong.",
+        taskType: "review",
+        priority: "medium",
+        whenObjectiveIncludes: ["build", "implement", "algorithm", "workflow"],
+        whenQuestionTypes: ["falsification", "counterfactual"]
+      }
+    ],
+    frameworkHints: [
+      {
+        frameworkName: "Boundary Audit",
+        whenObjectiveIncludes: ["handler", "contract", "api", "workflow"],
+        boost: 0.25,
+        reason: "Developer reasoning work benefits from explicit boundary checks."
+      },
+      {
+        frameworkName: "Pre-mortem",
+        whenQuestionTypes: ["falsification", "counterfactual"],
+        boost: 0.2,
+        reason: "Stress-testing likely failure modes improves worktree shaping quality."
+      }
+    ]
+  },
+  methodologyPackId: "developer"
+});
+
+// src/domain-pack/packs/engineering-accelerator.ts
+var ENGINEERING_ACCELERATOR_PACK = defineDomainPack({
+  packId: "engineering-accelerator",
+  name: "Engineering Accelerator",
+  version: "1.0.0",
+  ontologyBindings: [
+    {
+      ontologyId: "software-entities",
+      versionConstraint: "^1.0.0",
+      required: true,
+      provisionMode: "seed",
+      seedRef: "packages/pack-host/src/domain-pack/ontology/software-entities-v1.ts",
+      requiredEntityTypes: [
+        "repository",
+        "service",
+        "module",
+        "workflow",
+        "incident",
+        "migration",
+        "decision_record",
+        "agent"
+      ],
+      requiredEdgeTypes: [
+        "depends_on",
+        "owns",
+        "calls",
+        "blocks",
+        "reviews",
+        "mitigates",
+        "supersedes"
+      ]
+    }
+  ],
+  topicRoots: [
+    {
+      slug: "migrations",
+      name: "Migrations",
+      description: "Schema, API, and runtime migrations with blast-radius, rollback, and parity memory",
+      ontologyId: "software-entities"
+    },
+    {
+      slug: "reviews",
+      name: "Reviews",
+      description: "Pull-request and change-review workflows grounded in prior rationale and regressions",
+      ontologyId: "software-entities"
+    },
+    {
+      slug: "incidents",
+      name: "Incidents",
+      description: "Incident response driven by competing hypotheses, contradictions, and mitigations",
+      ontologyId: "software-entities"
+    },
+    {
+      slug: "architecture",
+      name: "Architecture",
+      description: "Architecture decisions, interface trade-offs, and precedent-aware rationale recall",
+      ontologyId: "software-entities"
+    },
+    {
+      slug: "decision-memory",
+      name: "Decision Memory",
+      description: "Cross-cutting rationale recall, failed attempts, and analog reuse across engineering work",
+      ontologyId: "software-entities"
+    }
+  ],
+  workflows: [
+    {
+      workflowId: "migration-readiness",
+      name: "Migration Readiness",
+      description: "Recall similar migrations, map blast radius, and define rollback before rollout",
+      steps: [
+        {
+          stepId: "recall-history",
+          name: "Recall History",
+          description: "Compile analogous migrations, prior rationale, failed attempts, and compatibility constraints",
+          requiredRoles: ["context-compiler", "migration-owner"],
+          produces: ["memory-brief"],
+          gateId: "memory-grounded"
+        },
+        {
+          stepId: "plan-rollout",
+          name: "Plan Rollout",
+          description: "Define blast radius, sequencing, rollback, and verification checkpoints",
+          requiredRoles: ["migration-owner", "critic"],
+          produces: ["migration-plan"],
+          gateId: "rollback-ready"
+        },
+        {
+          stepId: "verify-rollout",
+          name: "Verify Rollout",
+          description: "Confirm canary, rollback, and parity checks are explicit before execution",
+          requiredRoles: ["reviewer"],
+          produces: ["verification-checklist"],
+          gateId: "verification-covered"
+        }
+      ],
+      requiredArtifacts: [
+        "memory-brief",
+        "migration-plan",
+        "verification-checklist"
+      ],
+      gateCheckpoints: [
+        "memory-grounded",
+        "rollback-ready",
+        "verification-covered"
+      ]
+    },
+    {
+      workflowId: "pull-request-review",
+      name: "Pull Request Review",
+      description: "Use prior rationale, regressions, and verification history to review risky changes faster",
+      steps: [
+        {
+          stepId: "recall-review-context",
+          name: "Recall Review Context",
+          description: "Load earlier decisions, similar diffs, failed attempts, and relevant incidents",
+          requiredRoles: ["context-compiler", "reviewer"],
+          produces: ["review-context"],
+          gateId: "memory-grounded"
+        },
+        {
+          stepId: "inspect-diff",
+          name: "Inspect Diff",
+          description: "Surface risk areas, stale assumptions, and regressions that should block approval",
+          requiredRoles: ["reviewer", "critic"],
+          produces: ["review-findings"],
+          gateId: "review-risks-surfaced"
+        },
+        {
+          stepId: "verify-changes",
+          name: "Verify Changes",
+          description: "Tie approval to explicit typecheck, test, and integration evidence",
+          requiredRoles: ["reviewer"],
+          produces: ["verification-checklist"],
+          gateId: "verification-covered"
+        }
+      ],
+      requiredArtifacts: [
+        "review-context",
+        "review-findings",
+        "verification-checklist"
+      ],
+      gateCheckpoints: [
+        "memory-grounded",
+        "review-risks-surfaced",
+        "verification-covered"
+      ]
+    },
+    {
+      workflowId: "incident-response",
+      name: "Incident Response",
+      description: "Treat incidents as contradiction-heavy reasoning tasks before committing to a root cause",
+      steps: [
+        {
+          stepId: "collect-signal",
+          name: "Collect Signal",
+          description: "Assemble symptoms, recent changes, precedent incidents, and active hypotheses",
+          requiredRoles: ["context-compiler", "incident-commander"],
+          produces: ["incident-brief"],
+          gateId: "memory-grounded"
+        },
+        {
+          stepId: "surface-contradictions",
+          name: "Surface Contradictions",
+          description: "Make competing explanations explicit before mitigation narrows the search space",
+          requiredRoles: ["incident-commander", "critic"],
+          produces: ["contradiction-report"],
+          gateId: "contradictions-surfaced"
+        },
+        {
+          stepId: "plan-mitigation",
+          name: "Plan Mitigation",
+          description: "Choose mitigations with owners, reversibility, and verification paths",
+          requiredRoles: ["incident-commander", "reviewer"],
+          produces: ["mitigation-plan"],
+          gateId: "verification-covered"
+        }
+      ],
+      requiredArtifacts: [
+        "incident-brief",
+        "contradiction-report",
+        "mitigation-plan"
+      ],
+      gateCheckpoints: [
+        "memory-grounded",
+        "contradictions-surfaced",
+        "verification-covered"
+      ]
+    },
+    {
+      workflowId: "architecture-decision",
+      name: "Architecture Decision",
+      description: "Ground architecture choices in cited precedent, explicit alternatives, and follow-up risk",
+      steps: [
+        {
+          stepId: "recall-precedent",
+          name: "Recall Precedent",
+          description: "Gather analogous decisions, trade-offs, reversals, and evidence already in the graph",
+          requiredRoles: ["context-compiler", "architect"],
+          produces: ["decision-brief"],
+          gateId: "memory-grounded"
+        },
+        {
+          stepId: "compare-options",
+          name: "Compare Options",
+          description: "Contrast viable paths, show what changes, and surface objections early",
+          requiredRoles: ["architect", "critic"],
+          produces: ["decision-brief"],
+          gateId: "decision-rationale-citable"
+        },
+        {
+          stepId: "record-decision",
+          name: "Record Decision",
+          description: "Capture the chosen path, cited rationale, and follow-up risks for later recall",
+          requiredRoles: ["architect"],
+          produces: ["decision-record"]
+        }
+      ],
+      requiredArtifacts: ["decision-brief", "decision-record"],
+      gateCheckpoints: ["memory-grounded", "decision-rationale-citable"]
+    }
+  ],
+  gates: [
+    {
+      gateId: "memory-grounded",
+      name: "Memory Grounded",
+      description: "The workflow is anchored in prior rationale, analogs, and failure memory before action",
+      criteria: [
+        {
+          criterionId: "precedent-cited",
+          description: "At least one prior change, incident, or decision is cited",
+          metric: "precedent_citations",
+          threshold: 1,
+          operator: "gte"
+        },
+        {
+          criterionId: "failure-log-checked",
+          description: "Relevant failed attempts or incident history were checked",
+          metric: "failure_log_checked",
+          threshold: 1,
+          operator: "eq"
+        }
+      ],
+      severity: "blocking"
+    },
+    {
+      gateId: "rollback-ready",
+      name: "Rollback Ready",
+      description: "Risky migrations cannot proceed without explicit rollback and blast-radius coverage",
+      criteria: [
+        {
+          criterionId: "blast-radius-scoped",
+          description: "Blast radius is enumerated for the proposed change",
+          metric: "blast_radius_scoped",
+          threshold: 1,
+          operator: "eq"
+        },
+        {
+          criterionId: "rollback-path-defined",
+          description: "Rollback path is explicit and reversible",
+          metric: "rollback_path_defined",
+          threshold: 1,
+          operator: "eq"
+        }
+      ],
+      severity: "blocking"
+    },
+    {
+      gateId: "review-risks-surfaced",
+      name: "Review Risks Surfaced",
+      description: "Review must explain what could regress and why approval is still justified",
+      criteria: [
+        {
+          criterionId: "risk-areas-documented",
+          description: "Risk areas and likely regressions are called out explicitly",
+          metric: "risk_areas_documented",
+          threshold: 1,
+          operator: "gte"
+        },
+        {
+          criterionId: "prior-regressions-checked",
+          description: "Reviewer checked analogous regressions or incidents",
+          metric: "prior_regressions_checked",
+          threshold: 1,
+          operator: "eq"
+        }
+      ],
+      severity: "blocking"
+    },
+    {
+      gateId: "contradictions-surfaced",
+      name: "Contradictions Surfaced",
+      description: "Incidents should preserve competing hypotheses long enough to avoid false certainty",
+      criteria: [
+        {
+          criterionId: "multiple-hypotheses",
+          description: "At least two plausible hypotheses remain visible",
+          metric: "competing_hypotheses_count",
+          threshold: 2,
+          operator: "gte"
+        },
+        {
+          criterionId: "contradictions-reviewed",
+          description: "Relevant contradictions or tensions were reviewed",
+          metric: "contradictions_reviewed",
+          threshold: 1,
+          operator: "gte"
+        }
+      ],
+      severity: "blocking"
+    },
+    {
+      gateId: "decision-rationale-citable",
+      name: "Decision Rationale Citable",
+      description: "Architecture choices should cite prior rationale and compare viable alternatives",
+      criteria: [
+        {
+          criterionId: "options-compared",
+          description: "At least two options are compared before choosing one",
+          metric: "options_compared",
+          threshold: 2,
+          operator: "gte"
+        },
+        {
+          criterionId: "prior-decisions-cited",
+          description: "Decision cites prior beliefs, ADRs, or incidents",
+          metric: "prior_decisions_cited",
+          threshold: 1,
+          operator: "gte"
+        }
+      ],
+      severity: "blocking"
+    },
+    {
+      gateId: "verification-covered",
+      name: "Verification Covered",
+      description: "Approval, rollout, and mitigation all require named verification paths",
+      criteria: [
+        {
+          criterionId: "checks-defined",
+          description: "At least one explicit verification path is named",
+          metric: "verification_paths_defined",
+          threshold: 1,
+          operator: "gte"
+        },
+        {
+          criterionId: "owners-named",
+          description: "Owners or on-call responsibility are explicit",
+          metric: "owner_count",
+          threshold: 1,
+          operator: "gte"
+        }
+      ],
+      severity: "blocking"
+    }
+  ],
+  artifacts: [
+    {
+      artifactId: "memory-brief",
+      name: "Memory Brief",
+      description: "A reusable brief of analogous changes, prior rationale, failed attempts, and contradictions",
+      stage: "recall-history",
+      contentSchema: {
+        type: "object",
+        properties: {
+          analogousChanges: { type: "array", items: { type: "string" } },
+          priorDecisions: { type: "array", items: { type: "string" } },
+          failedAttempts: { type: "array", items: { type: "string" } },
+          contradictions: { type: "array", items: { type: "string" } }
+        },
+        required: ["analogousChanges", "priorDecisions"]
+      },
+      requiredFields: ["analogousChanges", "priorDecisions"]
+    },
+    {
+      artifactId: "migration-plan",
+      name: "Migration Plan",
+      description: "Blast radius, rollback path, rollout checkpoints, and verification plan",
+      stage: "plan-rollout",
+      contentSchema: {
+        type: "object",
+        properties: {
+          blastRadius: { type: "array", items: { type: "string" } },
+          rollbackPlan: { type: "string" },
+          verificationPath: { type: "array", items: { type: "string" } },
+          canarySteps: { type: "array", items: { type: "string" } }
+        },
+        required: ["blastRadius", "rollbackPlan", "verificationPath"]
+      },
+      requiredFields: ["blastRadius", "rollbackPlan", "verificationPath"]
+    },
+    {
+      artifactId: "verification-checklist",
+      name: "Verification Checklist",
+      description: "Named checks, owners, and pass/fail criteria for rollout or approval",
+      stage: "verify-rollout",
+      contentSchema: {
+        type: "object",
+        properties: {
+          checks: { type: "array", items: { type: "string" } },
+          owners: { type: "array", items: { type: "string" } },
+          passCriteria: { type: "array", items: { type: "string" } }
+        },
+        required: ["checks", "owners"]
+      },
+      requiredFields: ["checks", "owners"]
+    },
+    {
+      artifactId: "review-context",
+      name: "Review Context",
+      description: "Prior rationale, related diffs, incidents, and failure history relevant to a review",
+      stage: "recall-review-context",
+      contentSchema: {
+        type: "object",
+        properties: {
+          rationaleLinks: { type: "array", items: { type: "string" } },
+          analogousDiffs: { type: "array", items: { type: "string" } },
+          relatedIncidents: { type: "array", items: { type: "string" } }
+        },
+        required: ["rationaleLinks"]
+      },
+      requiredFields: ["rationaleLinks"]
+    },
+    {
+      artifactId: "review-findings",
+      name: "Review Findings",
+      description: "What could regress, what evidence was checked, and whether the change should be blocked",
+      stage: "inspect-diff",
+      contentSchema: {
+        type: "object",
+        properties: {
+          findings: { type: "array", items: { type: "string" } },
+          regressionsChecked: { type: "array", items: { type: "string" } },
+          blockReason: { type: "string" }
+        },
+        required: ["findings", "regressionsChecked"]
+      },
+      requiredFields: ["findings", "regressionsChecked"]
+    },
+    {
+      artifactId: "incident-brief",
+      name: "Incident Brief",
+      description: "Signals, recent changes, competing hypotheses, and precedent incidents",
+      stage: "collect-signal",
+      contentSchema: {
+        type: "object",
+        properties: {
+          symptoms: { type: "array", items: { type: "string" } },
+          recentChanges: { type: "array", items: { type: "string" } },
+          competingHypotheses: { type: "array", items: { type: "string" } },
+          precedentIncidents: { type: "array", items: { type: "string" } }
+        },
+        required: ["symptoms", "competingHypotheses"]
+      },
+      requiredFields: ["symptoms", "competingHypotheses"]
+    },
+    {
+      artifactId: "contradiction-report",
+      name: "Contradiction Report",
+      description: "Active contradictions, why they matter, and what evidence could collapse them",
+      stage: "surface-contradictions",
+      contentSchema: {
+        type: "object",
+        properties: {
+          contradictions: { type: "array", items: { type: "string" } },
+          likelyRootCauses: { type: "array", items: { type: "string" } },
+          missingEvidence: { type: "array", items: { type: "string" } }
+        },
+        required: ["contradictions", "likelyRootCauses"]
+      },
+      requiredFields: ["contradictions", "likelyRootCauses"]
+    },
+    {
+      artifactId: "mitigation-plan",
+      name: "Mitigation Plan",
+      description: "Chosen mitigation, rollback path, and verification ownership for an incident",
+      stage: "plan-mitigation",
+      contentSchema: {
+        type: "object",
+        properties: {
+          mitigationSteps: { type: "array", items: { type: "string" } },
+          rollbackPlan: { type: "string" },
+          owners: { type: "array", items: { type: "string" } }
+        },
+        required: ["mitigationSteps", "owners"]
+      },
+      requiredFields: ["mitigationSteps", "owners"]
+    },
+    {
+      artifactId: "decision-brief",
+      name: "Decision Brief",
+      description: "Options, cited precedent, trade-offs, and objections for an architecture decision",
+      stage: "compare-options",
+      contentSchema: {
+        type: "object",
+        properties: {
+          options: { type: "array", items: { type: "string" } },
+          citedPrecedent: { type: "array", items: { type: "string" } },
+          objections: { type: "array", items: { type: "string" } }
+        },
+        required: ["options", "citedPrecedent"]
+      },
+      requiredFields: ["options", "citedPrecedent"]
+    },
+    {
+      artifactId: "decision-record",
+      name: "Decision Record",
+      description: "Chosen path, why it won, what it supersedes, and what follow-up remains open",
+      stage: "record-decision",
+      contentSchema: {
+        type: "object",
+        properties: {
+          decision: { type: "string" },
+          rationale: { type: "array", items: { type: "string" } },
+          supersedes: { type: "array", items: { type: "string" } },
+          followUps: { type: "array", items: { type: "string" } }
+        },
+        required: ["decision", "rationale"]
+      },
+      requiredFields: ["decision", "rationale"]
+    }
+  ],
+  roles: [
+    {
+      roleId: "context-compiler",
+      name: "Context Compiler",
+      description: "Compiles prior rationale, analogs, and failure memory into reusable first-hour context",
+      perspective: "History-first, evidence-weighted context assembly",
+      optimizesFor: "recall quality and anti-repetition coverage",
+      mayBlock: false
+    },
+    {
+      roleId: "migration-owner",
+      name: "Migration Owner",
+      description: "Scopes rollout blast radius, rollback, sequencing, and compatibility risk",
+      perspective: "Operational caution with explicit rollback discipline",
+      optimizesFor: "safe rollout planning",
+      mayBlock: false
+    },
+    {
+      roleId: "reviewer",
+      name: "Reviewer",
+      description: "Evaluates risky changes against prior regressions, evidence, and missing checks",
+      perspective: "Evidence-backed change approval with regression awareness",
+      optimizesFor: "defect prevention and clear approval rationale",
+      mayBlock: true
+    },
+    {
+      roleId: "incident-commander",
+      name: "Incident Commander",
+      description: "Maintains multiple plausible explanations while driving mitigation decisions",
+      perspective: "Fast, reversible action without collapsing uncertainty too early",
+      optimizesFor: "time-to-mitigation with preserved reasoning integrity",
+      mayBlock: false
+    },
+    {
+      roleId: "architect",
+      name: "Architect",
+      description: "Turns competing options into explicit decisions with cited precedent and follow-up risk",
+      perspective: "Trade-off clarity and long-term maintainability",
+      optimizesFor: "decision quality and rationale reuse",
+      mayBlock: false
+    },
+    {
+      roleId: "critic",
+      name: "Critic",
+      description: "Finds weak assumptions, missing rollback paths, and untested contradictions",
+      perspective: "Skeptical, adversarial, and detail-oriented",
+      optimizesFor: "early detection of brittle plans",
+      mayBlock: true
+    }
+  ],
+  inquiryShaping: {
+    questionTemplates: [
+      {
+        templateId: "engineering-rationale-recall",
+        questionType: "comparison",
+        priority: "high",
+        template: "Which prior migration, incident, review, or architecture decision most resembles {{objective}}, and what rationale or failure should we reuse before changing anything?",
+        whenObjectiveIncludes: [
+          "migration",
+          "review",
+          "pull request",
+          "incident",
+          "architecture",
+          "decision",
+          "rollback",
+          "refactor"
+        ]
+      },
+      {
+        templateId: "engineering-rollback-falsifier",
+        questionType: "falsification",
+        priority: "critical",
+        template: "What rollback, compatibility, or blast-radius assumption would fail first if {{hypothesis}} is wrong?",
+        whenObjectiveIncludes: ["migration", "deploy", "rollout", "backfill"]
+      },
+      {
+        templateId: "engineering-review-regression",
+        questionType: "counterfactual",
+        priority: "high",
+        template: "Which prior regression, incident, or failed attempt should a reviewer inspect before approving {{objective}}?",
+        whenObjectiveIncludes: ["review", "pull request", "diff", "merge"]
+      },
+      {
+        templateId: "engineering-incident-contradiction",
+        questionType: "mechanism",
+        priority: "high",
+        template: "Which competing hypothesis or contradiction must be surfaced before treating {{objective}} as the root cause?",
+        whenObjectiveIncludes: [
+          "incident",
+          "outage",
+          "error",
+          "latency",
+          "regression"
+        ]
+      },
+      {
+        templateId: "engineering-architecture-precedent",
+        questionType: "validation",
+        priority: "high",
+        template: "Which earlier architecture decision would {{objective}} narrow, supersede, or reaffirm, and what evidence justified it then?",
+        whenObjectiveIncludes: [
+          "architecture",
+          "decision",
+          "interface",
+          "contract",
+          "api",
+          "design"
+        ]
+      }
+    ],
+    taskTemplates: [
+      {
+        templateId: "engineering-memory-brief",
+        title: "Compile prior rationale, analogous changes, and failed attempts for {{objective}}",
+        description: "Create a first-hour memory brief so the workflow starts with precedent instead of rediscovery.",
+        taskType: "analysis",
+        priority: "urgent",
+        whenObjectiveIncludes: [
+          "migration",
+          "review",
+          "incident",
+          "architecture",
+          "decision",
+          "rollback"
+        ]
+      },
+      {
+        templateId: "engineering-rollback-check",
+        title: "Define blast radius, rollback path, and verification checkpoints for {{objective}}",
+        description: "Turn risky engineering work into a reversible plan before implementation or approval.",
+        taskType: "analysis",
+        priority: "high",
+        whenObjectiveIncludes: ["migration", "deploy", "rollout", "backfill"]
+      },
+      {
+        templateId: "engineering-review-brief",
+        title: "Draft a review brief linking prior rationale, regressions, and missing checks for {{objective}}",
+        description: "Use prior incidents and earlier review context to focus approval on what can actually break.",
+        taskType: "review",
+        priority: "high",
+        whenObjectiveIncludes: ["review", "pull request", "diff", "merge"]
+      },
+      {
+        templateId: "engineering-contradiction-sweep",
+        title: "Surface competing hypotheses and active contradictions for {{objective}}",
+        description: "Keep incident triage or regression analysis from collapsing into a single untested explanation.",
+        taskType: "analysis",
+        priority: "high",
+        whenObjectiveIncludes: [
+          "incident",
+          "outage",
+          "error",
+          "latency",
+          "regression"
+        ]
+      },
+      {
+        templateId: "engineering-decision-record",
+        title: "Capture cited precedent, rejected options, and follow-up risks for {{objective}}",
+        description: "Turn architecture decisions into explicit rationale that future work can recall instead of re-litigating.",
+        taskType: "analysis",
+        priority: "medium",
+        whenObjectiveIncludes: [
+          "architecture",
+          "decision",
+          "interface",
+          "contract",
+          "design",
+          "refactor"
+        ]
+      }
+    ],
+    frameworkHints: [
+      {
+        frameworkName: "Timeline Replay",
+        whenObjectiveIncludes: [
+          "migration",
+          "deploy",
+          "rollout",
+          "incident",
+          "rollback"
+        ],
+        boost: 0.28,
+        reason: "Migration and incident work benefits from replaying prior changes, causes, and rollback timing."
+      },
+      {
+        frameworkName: "Contradiction Sweep",
+        whenObjectiveIncludes: ["incident", "outage", "error", "regression"],
+        boost: 0.3,
+        reason: "Incidents need competing hypotheses surfaced explicitly before confidence collapses too early."
+      },
+      {
+        frameworkName: "ADR Delta Review",
+        whenObjectiveIncludes: [
+          "architecture",
+          "decision",
+          "interface",
+          "contract",
+          "design"
+        ],
+        boost: 0.26,
+        reason: "Architecture work should compare against earlier decisions and explain the delta, not just the new plan."
+      },
+      {
+        frameworkName: "Pre-Merge Regression Audit",
+        whenObjectiveIncludes: ["review", "pull request", "diff", "merge"],
+        boost: 0.24,
+        reason: "Risky reviews are faster and better when they start from prior regressions, rationale, and missing checks."
+      }
+    ]
+  },
+  operatingSystem: {
+    prompts: [
+      {
+        promptId: "claude-quick-reference",
+        description: "Claude Code quick-reference and Lucern operating loop",
+        source: "file",
+        ref: "CLAUDE.md",
+        channel: "bootstrap",
+        required: true,
+        runtimeTargets: ["claude-code", "hybrid"]
+      },
+      {
+        promptId: "build-command",
+        description: "Main-session worktree execution protocol",
+        source: "file",
+        ref: ".claude/commands/build.md",
+        channel: "workflow",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        promptId: "architect-command",
+        description: "Product-architecture framing command",
+        source: "file",
+        ref: ".claude/commands/architect.md",
+        channel: "analysis",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        promptId: "pipeline-command",
+        description: "Pipeline sequencing and queue-management command",
+        source: "file",
+        ref: ".claude/commands/pipeline.md",
+        channel: "analysis",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        promptId: "pr-command",
+        description: "PR gating and merge-close workflow command",
+        source: "file",
+        ref: ".claude/commands/pr.md",
+        channel: "review",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        promptId: "lucern-generate-questions",
+        description: "Langfuse prompt for pack-shaped question generation",
+        source: "langfuse",
+        ref: "lucern/generate-questions",
+        channel: "analysis",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid", "portable"]
+      },
+      {
+        promptId: "lucern-contradiction-analysis",
+        description: "Langfuse prompt for contradiction-heavy debugging and incidents",
+        source: "langfuse",
+        ref: "lucern/contradiction-analysis",
+        channel: "review",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid", "portable"]
+      }
+    ],
+    tools: [
+      {
+        toolId: "start-investigation",
+        description: "Canonical graph bootstrap before coding or review",
+        kind: "mcp",
+        entrypoint: "compile_context",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid", "portable"]
+      },
+      {
+        toolId: "record-scope-learning",
+        description: "Commit-level ledger writeback with touched paths",
+        kind: "mcp",
+        entrypoint: "record_scope_learning",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid", "portable"]
+      },
+      {
+        toolId: "record-attempt",
+        description: "Anti-repetition failure logging during implementation",
+        kind: "mcp",
+        entrypoint: "record_attempt",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid", "portable"]
+      },
+      {
+        toolId: "pipeline-snapshot",
+        description: "Execution-band and track-aware pipeline summary",
+        kind: "mcp",
+        entrypoint: "pipeline_snapshot",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid", "portable"]
+      },
+      {
+        toolId: "session-init",
+        description: "SessionStart hook bootstrap for Lucern context",
+        kind: "hook",
+        entrypoint: "npx tsx apps/mcp-server/src/cli.ts session-init",
+        required: true,
+        runtimeTargets: ["claude-code", "hybrid"]
+      },
+      {
+        toolId: "tool-log",
+        description: "Post-tool ledger logger and edit-counter reset hook",
+        kind: "hook",
+        entrypoint: "npx tsx apps/mcp-server/src/cli.ts tool-log",
+        required: true,
+        runtimeTargets: ["claude-code", "hybrid"]
+      },
+      {
+        toolId: "build-bash-gate",
+        description: "Commit and PR gate enforcing ledger plus knowledge writes",
+        kind: "hook",
+        entrypoint: "npx tsx apps/mcp-server/src/cli.ts build-bash-gate",
+        required: true,
+        runtimeTargets: ["claude-code", "hybrid"]
+      },
+      {
+        toolId: "lucern-cli-init",
+        description: "One-step MCP setup for new repositories",
+        kind: "cli",
+        entrypoint: "npx tsx apps/mcp-server/src/cli.ts init",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        toolId: "kit-install",
+        description: "Manifest-driven installer for the turnkey Lucern engineering solution pack",
+        kind: "cli",
+        entrypoint: "npx tsx apps/mcp-server/src/cli.ts kit install developer-engineering",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      }
+    ],
+    setupAssets: [
+      {
+        assetId: "claude-instructions",
+        kind: "instruction",
+        description: "Primary Claude Code quick-reference and Lucern protocol",
+        path: "CLAUDE.md",
+        required: true,
+        runtimeTargets: ["claude-code", "hybrid"]
+      },
+      {
+        assetId: "codex-bridge",
+        kind: "instruction",
+        description: "Codex bridge instructions for Lucern-native development",
+        path: "AGENTS.md",
+        required: true,
+        runtimeTargets: ["codex", "hybrid"]
+      },
+      {
+        assetId: "mcp-config",
+        kind: "manifest",
+        description: "MCP server registry including lucern-graph",
+        path: ".mcp.json",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        assetId: "kit-manifest",
+        kind: "manifest",
+        description: "Serialized engineering kit blueprint capturing prompts, tools, ontology, and topic scaffolding",
+        path: ".lucern/kits/developer-engineering.json",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        assetId: "lucern-launcher",
+        kind: "script",
+        description: "Launch script used by MCP clients to start lucern-graph",
+        path: "scripts/lucern_start",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        assetId: "lucern-shell-wrapper",
+        kind: "script",
+        description: "Shell wrapper for invoking Lucern CLI commands with credential resolution",
+        path: "scripts/lucern",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        assetId: "lucern-cli-script",
+        kind: "script",
+        description: "CLI entrypoint for hook commands, init, sync, and kit installation",
+        path: "apps/mcp-server/src/cli.ts",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        assetId: "claude-settings",
+        kind: "settings",
+        description: "Claude hook wiring and enforcement defaults",
+        path: ".claude/settings.json",
+        required: true,
+        runtimeTargets: ["claude-code", "hybrid"]
+      },
+      {
+        assetId: "permission-gate-hook",
+        kind: "hook",
+        description: "Rule-based permission gate for risky tool usage",
+        path: ".claude/hooks/permission-gate.sh",
+        required: true,
+        runtimeTargets: ["claude-code", "hybrid"]
+      },
+      {
+        assetId: "inbox-check-hook",
+        kind: "hook",
+        description: "Session-start inbox and PR queue surfacing",
+        path: ".claude/hooks/inbox-check.sh",
+        required: true,
+        runtimeTargets: ["claude-code", "hybrid"]
+      },
+      {
+        assetId: "prompt-router-hook",
+        kind: "hook",
+        description: "Prompt router for /build validation and inbox context",
+        path: ".claude/hooks/prompt-router.sh",
+        required: true,
+        runtimeTargets: ["claude-code", "hybrid"]
+      },
+      {
+        assetId: "writeback-gate-hook",
+        kind: "hook",
+        description: "Session-close writeback quality gate",
+        path: ".claude/hooks/writeback-gate.sh",
+        required: true,
+        runtimeTargets: ["claude-code", "hybrid"]
+      },
+      {
+        assetId: "build-command-doc",
+        kind: "template",
+        description: "Inline /build command contract",
+        path: ".claude/commands/build.md",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        assetId: "architect-command-doc",
+        kind: "template",
+        description: "Inline /architect command contract",
+        path: ".claude/commands/architect.md",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        assetId: "pipeline-command-doc",
+        kind: "template",
+        description: "Inline /pipeline command contract",
+        path: ".claude/commands/pipeline.md",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        assetId: "pr-command-doc",
+        kind: "template",
+        description: "Inline /pr command contract",
+        path: ".claude/commands/pr.md",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        assetId: "claude-agent-catalog",
+        kind: "agent",
+        description: "Curated agent catalog for architecture, pipeline, QA, and PR review",
+        path: ".claude/agents",
+        required: true,
+        runtimeTargets: ["claude-code", "hybrid"]
+      },
+      {
+        assetId: "claude-skill-catalog",
+        kind: "skill",
+        description: "Skill catalog containing build, pipeline, product-architect, and Lucern workflows",
+        path: ".claude/skills",
+        required: true,
+        runtimeTargets: ["claude-code", "hybrid"]
+      },
+      {
+        assetId: "skills-sync-script",
+        kind: "script",
+        description: "Bridge script for syncing Claude and Codex skill mirrors",
+        path: "scripts/sync_codex_claude_skills.sh",
+        required: true,
+        runtimeTargets: ["codex", "hybrid"]
+      },
+      {
+        assetId: "hooks-doc",
+        kind: "template",
+        description: "Hook architecture and writeback enforcement reference",
+        path: "docs/operations/hooks.md",
+        required: true,
+        runtimeTargets: ["claude-code", "codex", "hybrid"]
+      },
+      {
+        assetId: "setup-ui",
+        kind: "ui",
+        description: "Portal setup surface showing quickstart and bootstrap steps",
+        path: "_template/dev/page.tsx",
+        required: false,
+        runtimeTargets: ["portable", "claude-code", "codex", "hybrid"]
+      }
+    ],
+    topicTemplates: [
+      {
+        slug: "migration-precedent",
+        name: "Migration Precedent",
+        description: "Analogous schema and rollout changes worth recalling before execution",
+        parentSlug: "migrations",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "rollback-playbooks",
+        name: "Rollback Playbooks",
+        description: "Named rollback strategies and canary escape hatches for risky changes",
+        parentSlug: "migrations",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "review-briefs",
+        name: "Review Briefs",
+        description: "Diff-scoped risk briefs grounded in prior regressions and rationale",
+        parentSlug: "reviews",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "regression-history",
+        name: "Regression History",
+        description: "Past regressions and approval misses that should influence current reviews",
+        parentSlug: "reviews",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "active-incidents",
+        name: "Active Incidents",
+        description: "Current incidents with competing hypotheses, mitigations, and contradictions",
+        parentSlug: "incidents",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "incident-postmortems",
+        name: "Incident Postmortems",
+        description: "Resolved incidents with preserved rationale and follow-up learnings",
+        parentSlug: "incidents",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "adrs",
+        name: "Architecture Decision Records",
+        description: "Citable architecture records with precedent, objections, and supersessions",
+        parentSlug: "architecture",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "interface-contracts",
+        name: "Interface Contracts",
+        description: "APIs, boundaries, and contract deltas that architecture work depends on",
+        parentSlug: "architecture",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "failed-attempts",
+        name: "Failed Attempts",
+        description: "Anti-repetition log for engineering decisions and implementation dead ends",
+        parentSlug: "decision-memory",
+        ontologyId: "software-entities"
+      },
+      {
+        slug: "rationale-recall",
+        name: "Rationale Recall",
+        description: "Recalled rationale snippets and analogs worth citing before new work",
+        parentSlug: "decision-memory",
+        ontologyId: "software-entities"
+      }
+    ],
+    installProfiles: [
+      {
+        profileId: "claude-code",
+        name: "Claude Code Engineering Kit",
+        description: "Installs Claude-native hooks, commands, agent catalog, and first-hour engineering prompts on top of Lucern.",
+        runtimeTarget: "claude-code",
+        promptIds: [
+          "claude-quick-reference",
+          "build-command",
+          "architect-command",
+          "pipeline-command",
+          "pr-command",
+          "lucern-generate-questions",
+          "lucern-contradiction-analysis"
+        ],
+        toolIds: [
+          "start-investigation",
+          "record-scope-learning",
+          "record-attempt",
+          "pipeline-snapshot",
+          "session-init",
+          "tool-log",
+          "build-bash-gate",
+          "lucern-cli-init",
+          "kit-install"
+        ],
+        assetIds: [
+          "claude-instructions",
+          "mcp-config",
+          "kit-manifest",
+          "lucern-launcher",
+          "lucern-shell-wrapper",
+          "lucern-cli-script",
+          "claude-settings",
+          "permission-gate-hook",
+          "inbox-check-hook",
+          "prompt-router-hook",
+          "writeback-gate-hook",
+          "build-command-doc",
+          "architect-command-doc",
+          "pipeline-command-doc",
+          "pr-command-doc",
+          "claude-agent-catalog",
+          "claude-skill-catalog",
+          "hooks-doc",
+          "setup-ui"
+        ],
+        defaultTopicSlugs: [
+          "migrations",
+          "reviews",
+          "incidents",
+          "architecture",
+          "decision-memory"
+        ]
+      },
+      {
+        profileId: "codex",
+        name: "Codex Engineering Kit",
+        description: "Installs the Codex bridge, Lucern MCP wiring, and the same pack-level workflows without Claude-specific hooks.",
+        runtimeTarget: "codex",
+        promptIds: [
+          "build-command",
+          "architect-command",
+          "pipeline-command",
+          "pr-command",
+          "lucern-generate-questions",
+          "lucern-contradiction-analysis"
+        ],
+        toolIds: [
+          "start-investigation",
+          "record-scope-learning",
+          "record-attempt",
+          "pipeline-snapshot",
+          "lucern-cli-init",
+          "kit-install"
+        ],
+        assetIds: [
+          "codex-bridge",
+          "mcp-config",
+          "kit-manifest",
+          "lucern-launcher",
+          "lucern-shell-wrapper",
+          "lucern-cli-script",
+          "build-command-doc",
+          "architect-command-doc",
+          "pipeline-command-doc",
+          "pr-command-doc",
+          "claude-skill-catalog",
+          "skills-sync-script",
+          "hooks-doc",
+          "setup-ui"
+        ],
+        defaultTopicSlugs: [
+          "migrations",
+          "reviews",
+          "incidents",
+          "architecture",
+          "decision-memory"
+        ]
+      },
+      {
+        profileId: "hybrid",
+        name: "Hybrid Engineering Kit",
+        description: "Installs both Claude and Codex entry surfaces against one Lucern-native engineering operating system.",
+        runtimeTarget: "hybrid",
+        promptIds: [
+          "claude-quick-reference",
+          "build-command",
+          "architect-command",
+          "pipeline-command",
+          "pr-command",
+          "lucern-generate-questions",
+          "lucern-contradiction-analysis"
+        ],
+        toolIds: [
+          "start-investigation",
+          "record-scope-learning",
+          "record-attempt",
+          "pipeline-snapshot",
+          "session-init",
+          "tool-log",
+          "build-bash-gate",
+          "lucern-cli-init",
+          "kit-install"
+        ],
+        assetIds: [
+          "claude-instructions",
+          "codex-bridge",
+          "mcp-config",
+          "kit-manifest",
+          "lucern-launcher",
+          "lucern-shell-wrapper",
+          "lucern-cli-script",
+          "claude-settings",
+          "permission-gate-hook",
+          "inbox-check-hook",
+          "prompt-router-hook",
+          "writeback-gate-hook",
+          "build-command-doc",
+          "architect-command-doc",
+          "pipeline-command-doc",
+          "pr-command-doc",
+          "claude-agent-catalog",
+          "claude-skill-catalog",
+          "skills-sync-script",
+          "hooks-doc",
+          "setup-ui"
+        ],
+        defaultTopicSlugs: [
+          "migrations",
+          "reviews",
+          "incidents",
+          "architecture",
+          "decision-memory"
+        ]
+      }
+    ]
+  },
+  appPackKeys: [
+    "chat-v1",
+    "documents-v1",
+    "epistemic-algorithms-v1",
+    "graph-visualization-v1",
+    "task-management-v1"
+  ],
+  methodologyPackId: "developer"
+});
+
+// src/domain-pack/packs/index.ts
+var DOMAIN_PACKS = {
+  "developer-reasoning": DEVELOPER_REASONING_PACK,
+  "engineering-accelerator": ENGINEERING_ACCELERATOR_PACK
+};
+var shapingContributionRegistry = createShapingContributionRegistry(
+  Object.values(DOMAIN_PACKS)
+);
+function getDomainPack(packId) {
+  return DOMAIN_PACKS[packId] ?? null;
+}
+function listDomainPacks() {
+  return Object.keys(DOMAIN_PACKS);
+}
+function getShapingContribution(packId) {
+  return shapingContributionRegistry.get(packId);
+}
+function listShapingContributions() {
+  return shapingContributionRegistry.list();
+}
+
+export { DEVELOPER_REASONING_PACK, ENGINEERING_ACCELERATOR_PACK, SOFTWARE_ENTITIES_V1, buildShapingContribution, createDomainPackAuthoringTools, createShapingContributionRegistry, defineDomainPack, defineDomainPackAuthoringManifest, getDomainPack, getShapingContribution, listDomainPacks, listShapingContributions, parseDomainPackAuthoringManifest, previewDomainPackAuthoringManifest, previewDomainPackAuthoringManifestSource, publishDomainPackAuthoringManifest, publishDomainPackAuthoringManifestSource, serializeDomainPackAuthoringManifest, validateDomainPack, validateDomainPackAuthoringManifest, validateDomainPackAuthoringManifestSource, validateShapingContribution };
+//# sourceMappingURL=domain-pack.js.map
+//# sourceMappingURL=domain-pack.js.map