@lucern/pack-host 1.0.0 → 1.0.2

package/dist/domain-pack/index.js

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