@lucern/pack-host 0.1.0-alpha.2

package/dist/domain-pack/shaping.js

@@ -0,0 +1,1013 @@
+// src/domain-pack/validation.ts
+function issue(code, message, path, severity = "error") {
+  return { code, severity, message, path };
+}
+var KEBAB_CASE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+var SHAPING_QUESTION_TYPES = /* @__PURE__ */ new Set([
+  "validation",
+  "falsification",
+  "assumption_probe",
+  "counterfactual",
+  "scope",
+  "comparison",
+  "mechanism",
+  "general"
+]);
+var RUNTIME_TARGETS = /* @__PURE__ */ new Set(["claude-code", "codex", "hybrid", "portable"]);
+var ONTOLOGY_PROVISION_MODES = /* @__PURE__ */ new Set(["bind", "seed", "extend"]);
+function validateStringArray(values, path, label) {
+  if (!values) {
+    return [];
+  }
+  return values.flatMap((value, index) => {
+    if (!value?.trim()) {
+      return [
+        issue(
+          "INVALID_SHAPING_CONDITION",
+          `${label} must not contain empty strings`,
+          `${path}[${index}]`
+        )
+      ];
+    }
+    return [];
+  });
+}
+function validateRuntimeTargets(values, path) {
+  const issues = validateStringArray(values, path, "runtimeTargets");
+  for (const [index, value] of (values || []).entries()) {
+    if (!RUNTIME_TARGETS.has(value)) {
+      issues.push(
+        issue(
+          "INVALID_RUNTIME_TARGET",
+          `Unsupported runtime target "${value}"`,
+          `${path}[${index}]`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function validatePromptBinding(prompt, index) {
+  const path = `operatingSystem.prompts[${index}]`;
+  const issues = [];
+  if (!prompt.promptId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_PROMPT_ID",
+        "prompt binding requires promptId",
+        `${path}.promptId`
+      )
+    );
+  }
+  if (!prompt.ref?.trim()) {
+    issues.push(
+      issue("MISSING_PROMPT_REF", "prompt binding requires ref", `${path}.ref`)
+    );
+  }
+  issues.push(
+    ...validateRuntimeTargets(prompt.runtimeTargets, `${path}.runtimeTargets`)
+  );
+  return issues;
+}
+function validateToolBinding(tool, index) {
+  const path = `operatingSystem.tools[${index}]`;
+  const issues = [];
+  if (!tool.toolId?.trim()) {
+    issues.push(
+      issue("MISSING_TOOL_ID", "tool binding requires toolId", `${path}.toolId`)
+    );
+  }
+  if (!tool.entrypoint?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOOL_ENTRYPOINT",
+        "tool binding requires entrypoint",
+        `${path}.entrypoint`
+      )
+    );
+  }
+  issues.push(
+    ...validateRuntimeTargets(tool.runtimeTargets, `${path}.runtimeTargets`)
+  );
+  return issues;
+}
+function validateSetupAsset(asset, index) {
+  const path = `operatingSystem.setupAssets[${index}]`;
+  const issues = [];
+  if (!asset.assetId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_SETUP_ASSET_ID",
+        "setup asset requires assetId",
+        `${path}.assetId`
+      )
+    );
+  }
+  if (!asset.path?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_SETUP_ASSET_PATH",
+        "setup asset requires path",
+        `${path}.path`
+      )
+    );
+  }
+  issues.push(
+    ...validateRuntimeTargets(asset.runtimeTargets, `${path}.runtimeTargets`)
+  );
+  return issues;
+}
+function validateQuestionTemplate(template, index) {
+  const path = `inquiryShaping.questionTemplates[${index}]`;
+  const issues = [];
+  if (!template.templateId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_SHAPING_TEMPLATE_ID",
+        "question template requires templateId",
+        `${path}.templateId`
+      )
+    );
+  }
+  if (!template.template?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_SHAPING_TEMPLATE",
+        "question template requires template text",
+        `${path}.template`
+      )
+    );
+  }
+  if (!SHAPING_QUESTION_TYPES.has(template.questionType)) {
+    issues.push(
+      issue(
+        "INVALID_SHAPING_QUESTION_TYPE",
+        `Unsupported questionType "${template.questionType}"`,
+        `${path}.questionType`
+      )
+    );
+  }
+  issues.push(
+    ...validateStringArray(
+      template.whenObjectiveIncludes,
+      `${path}.whenObjectiveIncludes`,
+      "whenObjectiveIncludes"
+    )
+  );
+  return issues;
+}
+function validateTaskTemplate(template, index) {
+  const path = `inquiryShaping.taskTemplates[${index}]`;
+  const issues = [];
+  if (!template.templateId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TASK_GENERATOR_ID",
+        "task template requires templateId",
+        `${path}.templateId`
+      )
+    );
+  }
+  if (!template.title?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TASK_GENERATOR_TITLE",
+        "task template requires title",
+        `${path}.title`
+      )
+    );
+  }
+  issues.push(
+    ...validateStringArray(
+      template.whenObjectiveIncludes,
+      `${path}.whenObjectiveIncludes`,
+      "whenObjectiveIncludes"
+    )
+  );
+  issues.push(
+    ...validateStringArray(
+      template.whenQuestionTypes,
+      `${path}.whenQuestionTypes`,
+      "whenQuestionTypes"
+    )
+  );
+  for (const [questionTypeIndex, questionType] of (template.whenQuestionTypes || []).entries()) {
+    if (!SHAPING_QUESTION_TYPES.has(questionType)) {
+      issues.push(
+        issue(
+          "INVALID_TASK_GENERATOR_QUESTION_TYPE",
+          `Unsupported whenQuestionTypes value "${questionType}"`,
+          `${path}.whenQuestionTypes[${questionTypeIndex}]`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function validateFrameworkHint(hint, index) {
+  const path = `inquiryShaping.frameworkHints[${index}]`;
+  const issues = [];
+  if (!hint.frameworkName?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_FRAMEWORK_HOOK_NAME",
+        "framework hint requires frameworkName",
+        `${path}.frameworkName`
+      )
+    );
+  }
+  if (hint.boost != null && (!Number.isFinite(hint.boost) || hint.boost < 0)) {
+    issues.push(
+      issue(
+        "INVALID_FRAMEWORK_HOOK_BOOST",
+        "framework hint boost must be a non-negative number",
+        `${path}.boost`
+      )
+    );
+  }
+  issues.push(
+    ...validateStringArray(
+      hint.whenObjectiveIncludes,
+      `${path}.whenObjectiveIncludes`,
+      "whenObjectiveIncludes"
+    )
+  );
+  issues.push(
+    ...validateStringArray(
+      hint.whenQuestionTypes,
+      `${path}.whenQuestionTypes`,
+      "whenQuestionTypes"
+    )
+  );
+  for (const [questionTypeIndex, questionType] of (hint.whenQuestionTypes || []).entries()) {
+    if (!SHAPING_QUESTION_TYPES.has(questionType)) {
+      issues.push(
+        issue(
+          "INVALID_FRAMEWORK_HOOK_QUESTION_TYPE",
+          `Unsupported whenQuestionTypes value "${questionType}"`,
+          `${path}.whenQuestionTypes[${questionTypeIndex}]`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function validateTopicTemplate(template, index, knownTopicSlugs) {
+  const path = `operatingSystem.topicTemplates[${index}]`;
+  const issues = [];
+  if (!template.slug?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_TEMPLATE_SLUG",
+        "topic template requires slug",
+        `${path}.slug`
+      )
+    );
+  } else if (!KEBAB_CASE.test(template.slug)) {
+    issues.push(
+      issue(
+        "INVALID_TOPIC_TEMPLATE_SLUG",
+        `topic template slug "${template.slug}" must be kebab-case`,
+        `${path}.slug`
+      )
+    );
+  }
+  if (!template.name?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_TEMPLATE_NAME",
+        "topic template requires name",
+        `${path}.name`
+      )
+    );
+  }
+  if (!template.description?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_TEMPLATE_DESCRIPTION",
+        "topic template requires description",
+        `${path}.description`
+      )
+    );
+  }
+  if (template.parentSlug && !knownTopicSlugs.has(template.parentSlug)) {
+    issues.push(
+      issue(
+        "UNKNOWN_TOPIC_PARENT",
+        `topic template references unknown parent "${template.parentSlug}"`,
+        `${path}.parentSlug`
+      )
+    );
+  }
+  return issues;
+}
+function validateInstallProfile(profile, index, knownPromptIds, knownToolIds, knownAssetIds, knownTopicSlugs) {
+  const path = `operatingSystem.installProfiles[${index}]`;
+  const issues = [];
+  if (!profile.profileId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_INSTALL_PROFILE_ID",
+        "install profile requires profileId",
+        `${path}.profileId`
+      )
+    );
+  }
+  if (!profile.name?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_INSTALL_PROFILE_NAME",
+        "install profile requires name",
+        `${path}.name`
+      )
+    );
+  }
+  if (!profile.description?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_INSTALL_PROFILE_DESCRIPTION",
+        "install profile requires description",
+        `${path}.description`
+      )
+    );
+  }
+  if (!RUNTIME_TARGETS.has(profile.runtimeTarget)) {
+    issues.push(
+      issue(
+        "INVALID_RUNTIME_TARGET",
+        `Unsupported runtime target "${profile.runtimeTarget}"`,
+        `${path}.runtimeTarget`
+      )
+    );
+  }
+  for (const [promptIndex, promptId] of profile.promptIds.entries()) {
+    if (!knownPromptIds.has(promptId)) {
+      issues.push(
+        issue(
+          "UNKNOWN_PROMPT_REF",
+          `install profile references unknown prompt "${promptId}"`,
+          `${path}.promptIds[${promptIndex}]`
+        )
+      );
+    }
+  }
+  for (const [toolIndex, toolId] of profile.toolIds.entries()) {
+    if (!knownToolIds.has(toolId)) {
+      issues.push(
+        issue(
+          "UNKNOWN_TOOL_REF",
+          `install profile references unknown tool "${toolId}"`,
+          `${path}.toolIds[${toolIndex}]`
+        )
+      );
+    }
+  }
+  for (const [assetIndex, assetId] of profile.assetIds.entries()) {
+    if (!knownAssetIds.has(assetId)) {
+      issues.push(
+        issue(
+          "UNKNOWN_SETUP_ASSET_REF",
+          `install profile references unknown setup asset "${assetId}"`,
+          `${path}.assetIds[${assetIndex}]`
+        )
+      );
+    }
+  }
+  for (const [topicIndex, topicSlug] of profile.defaultTopicSlugs.entries()) {
+    if (!knownTopicSlugs.has(topicSlug)) {
+      issues.push(
+        issue(
+          "UNKNOWN_TOPIC_REF",
+          `install profile references unknown topic "${topicSlug}"`,
+          `${path}.defaultTopicSlugs[${topicIndex}]`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function checkDuplicateIds(items, idField, path) {
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const id = item[idField];
+    if (seen.has(id)) {
+      issues.push(
+        issue(
+          "DUPLICATE_ID",
+          `Duplicate ${idField} "${id}"`,
+          `${path}.${idField}`
+        )
+      );
+    }
+    seen.add(id);
+  }
+  return issues;
+}
+function validateDomainPack(pack) {
+  const issues = [];
+  if (!pack.packId || !pack.packId.trim()) {
+    issues.push(issue("MISSING_PACK_ID", "packId is required", "packId"));
+  } else if (!KEBAB_CASE.test(pack.packId)) {
+    issues.push(
+      issue(
+        "INVALID_PACK_ID",
+        `packId "${pack.packId}" must be kebab-case`,
+        "packId"
+      )
+    );
+  }
+  if (!pack.name || !pack.name.trim()) {
+    issues.push(issue("MISSING_NAME", "name is required", "name"));
+  }
+  if (!pack.version || !pack.version.trim()) {
+    issues.push(issue("MISSING_VERSION", "version is required", "version"));
+  } else if (!SEMVER.test(pack.version)) {
+    issues.push(
+      issue(
+        "INVALID_VERSION",
+        `version "${pack.version}" must be valid semver`,
+        "version"
+      )
+    );
+  }
+  if (!pack.ontologyBindings || pack.ontologyBindings.length === 0) {
+    issues.push(
+      issue(
+        "MISSING_ONTOLOGY_BINDINGS",
+        "At least one ontologyBinding is required",
+        "ontologyBindings"
+      )
+    );
+  } else {
+    for (const [i, binding] of pack.ontologyBindings.entries()) {
+      if (!binding.ontologyId?.trim()) {
+        issues.push(
+          issue(
+            "MISSING_ONTOLOGY_ID",
+            `ontologyBinding[${i}].ontologyId is required`,
+            `ontologyBindings[${i}].ontologyId`
+          )
+        );
+      }
+      if (!binding.versionConstraint?.trim()) {
+        issues.push(
+          issue(
+            "MISSING_VERSION_CONSTRAINT",
+            `ontologyBinding[${i}].versionConstraint is required`,
+            `ontologyBindings[${i}].versionConstraint`
+          )
+        );
+      }
+      if (binding.provisionMode && !ONTOLOGY_PROVISION_MODES.has(binding.provisionMode)) {
+        issues.push(
+          issue(
+            "INVALID_ONTOLOGY_PROVISION_MODE",
+            `Unsupported provisionMode "${binding.provisionMode}"`,
+            `ontologyBindings[${i}].provisionMode`
+          )
+        );
+      }
+      if (binding.provisionMode && binding.provisionMode !== "bind" && !binding.seedRef?.trim()) {
+        issues.push(
+          issue(
+            "MISSING_ONTOLOGY_SEED_REF",
+            `ontologyBinding[${i}] requires seedRef when provisionMode is "${binding.provisionMode}"`,
+            `ontologyBindings[${i}].seedRef`
+          )
+        );
+      }
+      issues.push(
+        ...validateStringArray(
+          binding.requiredEntityTypes,
+          `ontologyBindings[${i}].requiredEntityTypes`,
+          "requiredEntityTypes"
+        ),
+        ...validateStringArray(
+          binding.requiredEdgeTypes,
+          `ontologyBindings[${i}].requiredEdgeTypes`,
+          "requiredEdgeTypes"
+        )
+      );
+    }
+  }
+  if (!pack.topicRoots || pack.topicRoots.length === 0) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_ROOTS",
+        "At least one topicRoot is required",
+        "topicRoots"
+      )
+    );
+  } else {
+    issues.push(
+      ...checkDuplicateIds(
+        pack.topicRoots,
+        "slug",
+        "topicRoots"
+      )
+    );
+  }
+  if (pack.operatingSystem) {
+    const knownRootSlugs = new Set(
+      pack.topicRoots?.map((topic) => topic.slug) ?? []
+    );
+    if (pack.operatingSystem.prompts) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.operatingSystem.prompts,
+          "promptId",
+          "operatingSystem.prompts"
+        )
+      );
+      pack.operatingSystem.prompts.forEach((prompt, index) => {
+        issues.push(...validatePromptBinding(prompt, index));
+      });
+    }
+    if (pack.operatingSystem.tools) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.operatingSystem.tools,
+          "toolId",
+          "operatingSystem.tools"
+        )
+      );
+      pack.operatingSystem.tools.forEach((tool, index) => {
+        issues.push(...validateToolBinding(tool, index));
+      });
+    }
+    if (pack.operatingSystem.setupAssets) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.operatingSystem.setupAssets,
+          "assetId",
+          "operatingSystem.setupAssets"
+        )
+      );
+      pack.operatingSystem.setupAssets.forEach((asset, index) => {
+        issues.push(...validateSetupAsset(asset, index));
+      });
+    }
+    const templateSlugs = /* @__PURE__ */ new Set();
+    if (pack.operatingSystem.topicTemplates) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.operatingSystem.topicTemplates,
+          "slug",
+          "operatingSystem.topicTemplates"
+        )
+      );
+      pack.operatingSystem.topicTemplates.forEach((template) => {
+        if (template.slug) {
+          templateSlugs.add(template.slug);
+        }
+      });
+      const knownTopicSlugs = /* @__PURE__ */ new Set([...knownRootSlugs, ...templateSlugs]);
+      pack.operatingSystem.topicTemplates.forEach((template, index) => {
+        issues.push(...validateTopicTemplate(template, index, knownTopicSlugs));
+      });
+    }
+    if (pack.operatingSystem.installProfiles) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.operatingSystem.installProfiles,
+          "profileId",
+          "operatingSystem.installProfiles"
+        )
+      );
+      const knownPromptIds = new Set(
+        pack.operatingSystem.prompts?.map((prompt) => prompt.promptId) ?? []
+      );
+      const knownToolIds = new Set(
+        pack.operatingSystem.tools?.map((tool) => tool.toolId) ?? []
+      );
+      const knownAssetIds = new Set(
+        pack.operatingSystem.setupAssets?.map((asset) => asset.assetId) ?? []
+      );
+      const knownTopicSlugs = /* @__PURE__ */ new Set([...knownRootSlugs, ...templateSlugs]);
+      pack.operatingSystem.installProfiles.forEach((profile, index) => {
+        issues.push(
+          ...validateInstallProfile(
+            profile,
+            index,
+            knownPromptIds,
+            knownToolIds,
+            knownAssetIds,
+            knownTopicSlugs
+          )
+        );
+      });
+    }
+  }
+  if (!pack.roles || pack.roles.length === 0) {
+    issues.push(
+      issue("MISSING_ROLES", "At least one reasoning role is required", "roles")
+    );
+  } else {
+    issues.push(
+      ...checkDuplicateIds(
+        pack.roles,
+        "roleId",
+        "roles"
+      )
+    );
+  }
+  const knownGateIds = new Set(pack.gates?.map((g) => g.gateId) ?? []);
+  const knownArtifactIds = new Set(
+    pack.artifacts?.map((a) => a.artifactId) ?? []
+  );
+  const knownRoleIds = new Set(pack.roles?.map((r) => r.roleId) ?? []);
+  if (pack.gates) {
+    issues.push(
+      ...checkDuplicateIds(
+        pack.gates,
+        "gateId",
+        "gates"
+      )
+    );
+    for (const [i, gate] of pack.gates.entries()) {
+      if (!gate.criteria || gate.criteria.length === 0) {
+        issues.push(
+          issue(
+            "EMPTY_GATE_CRITERIA",
+            `Gate "${gate.gateId}" has no criteria`,
+            `gates[${i}].criteria`,
+            "warning"
+          )
+        );
+      } else {
+        issues.push(
+          ...checkDuplicateIds(
+            gate.criteria,
+            "criterionId",
+            `gates[${i}].criteria`
+          )
+        );
+      }
+    }
+  }
+  if (pack.artifacts) {
+    issues.push(
+      ...checkDuplicateIds(
+        pack.artifacts,
+        "artifactId",
+        "artifacts"
+      )
+    );
+  }
+  if (pack.workflows) {
+    issues.push(
+      ...checkDuplicateIds(
+        pack.workflows,
+        "workflowId",
+        "workflows"
+      )
+    );
+    for (const [wi, workflow] of pack.workflows.entries()) {
+      for (const gateId of workflow.gateCheckpoints) {
+        if (!knownGateIds.has(gateId)) {
+          issues.push(
+            issue(
+              "UNKNOWN_GATE_REF",
+              `Workflow "${workflow.workflowId}" references unknown gate "${gateId}"`,
+              `workflows[${wi}].gateCheckpoints`
+            )
+          );
+        }
+      }
+      for (const artifactId of workflow.requiredArtifacts) {
+        if (!knownArtifactIds.has(artifactId)) {
+          issues.push(
+            issue(
+              "UNKNOWN_ARTIFACT_REF",
+              `Workflow "${workflow.workflowId}" references unknown artifact "${artifactId}"`,
+              `workflows[${wi}].requiredArtifacts`
+            )
+          );
+        }
+      }
+      for (const [si, step] of workflow.steps.entries()) {
+        for (const roleId of step.requiredRoles) {
+          if (!knownRoleIds.has(roleId)) {
+            issues.push(
+              issue(
+                "UNKNOWN_ROLE_REF",
+                `Step "${step.stepId}" references unknown role "${roleId}"`,
+                `workflows[${wi}].steps[${si}].requiredRoles`
+              )
+            );
+          }
+        }
+        if (step.gateId && !knownGateIds.has(step.gateId)) {
+          issues.push(
+            issue(
+              "UNKNOWN_GATE_REF",
+              `Step "${step.stepId}" references unknown gate "${step.gateId}"`,
+              `workflows[${wi}].steps[${si}].gateId`
+            )
+          );
+        }
+        if (step.produces) {
+          for (const artifactId of step.produces) {
+            if (!knownArtifactIds.has(artifactId)) {
+              issues.push(
+                issue(
+                  "UNKNOWN_ARTIFACT_REF",
+                  `Step "${step.stepId}" references unknown artifact "${artifactId}"`,
+                  `workflows[${wi}].steps[${si}].produces`
+                )
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  if (pack.inquiryShaping) {
+    if (pack.inquiryShaping.questionTemplates) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.inquiryShaping.questionTemplates,
+          "templateId",
+          "inquiryShaping.questionTemplates"
+        )
+      );
+      pack.inquiryShaping.questionTemplates.forEach((template, index) => {
+        issues.push(...validateQuestionTemplate(template, index));
+      });
+    }
+    if (pack.inquiryShaping.taskTemplates) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.inquiryShaping.taskTemplates,
+          "templateId",
+          "inquiryShaping.taskTemplates"
+        )
+      );
+      pack.inquiryShaping.taskTemplates.forEach((template, index) => {
+        issues.push(...validateTaskTemplate(template, index));
+      });
+    }
+    if (pack.inquiryShaping.frameworkHints) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.inquiryShaping.frameworkHints.map((hint) => ({
+            frameworkName: hint.frameworkName
+          })),
+          "frameworkName",
+          "inquiryShaping.frameworkHints"
+        )
+      );
+      pack.inquiryShaping.frameworkHints.forEach((hint, index) => {
+        issues.push(...validateFrameworkHint(hint, index));
+      });
+    }
+  }
+  return {
+    valid: issues.filter((i) => i.severity === "error").length === 0,
+    issues
+  };
+}
+
+// src/domain-pack/shaping.ts
+var QUESTION_PRIORITY_WEIGHT = {
+  critical: 0.12,
+  high: 0.08,
+  medium: 0.04,
+  low: 0.01
+};
+var TASK_PRIORITY_WEIGHT = {
+  urgent: 0.12,
+  high: 0.08,
+  medium: 0.04,
+  low: 0.01
+};
+function dedupeStrings(values) {
+  if (!values || values.length === 0) {
+    return void 0;
+  }
+  const normalized = values.map((value) => value.trim()).filter(Boolean);
+  return normalized.length > 0 ? Array.from(new Set(normalized)) : void 0;
+}
+function toKebabCase(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeCondition(args) {
+  return {
+    ...dedupeStrings(args.objectiveIncludes) ? { objectiveIncludes: dedupeStrings(args.objectiveIncludes) } : {},
+    ...dedupeStrings(args.questionTypes) ? { questionTypes: dedupeStrings(args.questionTypes) } : {}
+  };
+}
+function normalizeQuestionType(questionType) {
+  return questionType === "scope" ? "clarification" : questionType;
+}
+function questionTemplateToContribution(packId, template) {
+  return {
+    sourcePackId: packId,
+    templateId: template.templateId,
+    questionType: normalizeQuestionType(template.questionType),
+    priority: template.priority,
+    priorityWeight: QUESTION_PRIORITY_WEIGHT[template.priority || "medium"],
+    template: template.template,
+    condition: normalizeCondition({
+      objectiveIncludes: template.whenObjectiveIncludes
+    })
+  };
+}
+function taskTemplateToContribution(packId, template) {
+  return {
+    sourcePackId: packId,
+    generatorId: template.templateId,
+    title: template.title,
+    description: template.description,
+    taskType: template.taskType,
+    priority: template.priority,
+    priorityWeight: TASK_PRIORITY_WEIGHT[template.priority || "medium"],
+    condition: normalizeCondition({
+      objectiveIncludes: template.whenObjectiveIncludes,
+      questionTypes: template.whenQuestionTypes
+    })
+  };
+}
+function frameworkHintToContribution(packId, hint) {
+  const hookId = `${packId}:${toKebabCase(hint.frameworkName || "framework")}`;
+  return {
+    sourcePackId: packId,
+    hookId,
+    frameworkName: hint.frameworkName,
+    boost: hint.boost || 0,
+    reason: hint.reason,
+    priorityWeight: Math.max(0.02, hint.boost || 0),
+    condition: normalizeCondition({
+      objectiveIncludes: hint.whenObjectiveIncludes,
+      questionTypes: hint.whenQuestionTypes
+    })
+  };
+}
+function issue2(code, message, path, severity = "error") {
+  return { code, message, path, severity };
+}
+function checkDuplicateIds2(items, idField, path) {
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const id = item[idField];
+    if (!id) {
+      continue;
+    }
+    if (seen.has(id)) {
+      issues.push(
+        issue2("DUPLICATE_ID", `Duplicate ${idField} "${id}"`, `${path}.${idField}`)
+      );
+    }
+    seen.add(id);
+  }
+  return issues;
+}
+function formatRegistrationIssues(packId, issues) {
+  return `Invalid shaping contribution registration for ${packId}: ${issues.map((item) => `${item.code} at ${item.path}`).join("; ")}`;
+}
+function buildShapingContribution(pack) {
+  const inquiryShaping = pack.inquiryShaping || {};
+  return {
+    packId: pack.packId,
+    questionTemplates: (inquiryShaping.questionTemplates || []).map(
+      (template) => questionTemplateToContribution(pack.packId, template)
+    ),
+    taskGenerators: (inquiryShaping.taskTemplates || []).map(
+      (template) => taskTemplateToContribution(pack.packId, template)
+    ),
+    frameworkHooks: (inquiryShaping.frameworkHints || []).map(
+      (hint) => frameworkHintToContribution(pack.packId, hint)
+    )
+  };
+}
+function validateShapingContribution(contribution) {
+  const issues = [];
+  if (!contribution.packId?.trim()) {
+    issues.push(issue2("MISSING_PACK_ID", "packId is required", "packId"));
+  }
+  issues.push(
+    ...checkDuplicateIds2(
+      contribution.questionTemplates,
+      "templateId",
+      "questionTemplates"
+    )
+  );
+  issues.push(
+    ...checkDuplicateIds2(
+      contribution.taskGenerators,
+      "generatorId",
+      "taskGenerators"
+    )
+  );
+  issues.push(
+    ...checkDuplicateIds2(
+      contribution.frameworkHooks,
+      "hookId",
+      "frameworkHooks"
+    )
+  );
+  contribution.questionTemplates.forEach((template, index) => {
+    if (!template.templateId?.trim()) {
+      issues.push(
+        issue2(
+          "MISSING_TEMPLATE_ID",
+          "Question template requires templateId",
+          `questionTemplates[${index}].templateId`
+        )
+      );
+    }
+    if (!template.template?.trim()) {
+      issues.push(
+        issue2(
+          "MISSING_TEMPLATE",
+          "Question template requires template text",
+          `questionTemplates[${index}].template`
+        )
+      );
+    }
+  });
+  contribution.taskGenerators.forEach((generator, index) => {
+    if (!generator.generatorId?.trim()) {
+      issues.push(
+        issue2(
+          "MISSING_GENERATOR_ID",
+          "Task generator requires generatorId",
+          `taskGenerators[${index}].generatorId`
+        )
+      );
+    }
+    if (!generator.title?.trim()) {
+      issues.push(
+        issue2(
+          "MISSING_TASK_TITLE",
+          "Task generator requires title",
+          `taskGenerators[${index}].title`
+        )
+      );
+    }
+  });
+  contribution.frameworkHooks.forEach((hook, index) => {
+    if (!hook.frameworkName?.trim()) {
+      issues.push(
+        issue2(
+          "MISSING_FRAMEWORK_NAME",
+          "Framework hook requires frameworkName",
+          `frameworkHooks[${index}].frameworkName`
+        )
+      );
+    }
+    if (!Number.isFinite(hook.boost) || hook.boost < 0) {
+      issues.push(
+        issue2(
+          "INVALID_FRAMEWORK_BOOST",
+          "Framework hook boost must be a non-negative number",
+          `frameworkHooks[${index}].boost`
+        )
+      );
+    }
+  });
+  return {
+    valid: issues.every((item) => item.severity !== "error"),
+    issues
+  };
+}
+function createShapingContributionRegistry(packs = []) {
+  const registry = /* @__PURE__ */ new Map();
+  const register = (pack) => {
+    if (registry.has(pack.packId)) {
+      throw new Error(
+        `Duplicate shaping contribution registration for ${pack.packId}`
+      );
+    }
+    const packValidation = validateDomainPack(pack);
+    if (!packValidation.valid) {
+      throw new Error(formatRegistrationIssues(pack.packId, packValidation.issues));
+    }
+    const contribution = buildShapingContribution(pack);
+    const contributionValidation = validateShapingContribution(contribution);
+    if (!contributionValidation.valid) {
+      throw new Error(
+        formatRegistrationIssues(pack.packId, contributionValidation.issues)
+      );
+    }
+    registry.set(pack.packId, contribution);
+    return contribution;
+  };
+  packs.forEach(register);
+  return {
+    register,
+    get(packId) {
+      return registry.get(packId) ?? null;
+    },
+    list() {
+      return Array.from(registry.keys());
+    }
+  };
+}
+
+export { buildShapingContribution, createShapingContributionRegistry, validateShapingContribution };
+//# sourceMappingURL=shaping.js.map
+//# sourceMappingURL=shaping.js.map