@lucern/pack-host 1.0.29 → 1.0.31

package/dist/domain-pack/packs/index.js

@@ -405,9 +405,14 @@ function checkDuplicateIds(items, idField, path) {
   }
   return issues;
 }
-function validateDomainPack(pack) {
-  const issues = [];
-  if (!pack.packId || !pack.packId.trim()) {
+function checkOptionalDuplicateIds(items, idField, path) {
+  if (!items) {
+    return [];
+  }
+  return checkDuplicateIds(items, idField, path);
+}
+function validatePackIdentity(pack, issues) {
+  if (typeof pack.packId !== "string" || pack.packId.trim().length === 0) {
     issues.push(issue("MISSING_PACK_ID", "packId is required", "packId"));
   } else if (!KEBAB_CASE.test(pack.packId)) {
     issues.push(
@@ -418,10 +423,10 @@ function validateDomainPack(pack) {
       )
     );
   }
-  if (!pack.name || !pack.name.trim()) {
+  if (typeof pack.name !== "string" || pack.name.trim().length === 0) {
     issues.push(issue("MISSING_NAME", "name is required", "name"));
   }
-  if (!pack.version || !pack.version.trim()) {
+  if (typeof pack.version !== "string" || pack.version.trim().length === 0) {
     issues.push(issue("MISSING_VERSION", "version is required", "version"));
   } else if (!SEMVER.test(pack.version)) {
     issues.push(
@@ -432,6 +437,8 @@ function validateDomainPack(pack) {
       )
     );
   }
+}
+function validateOntologyBindings(pack, issues) {
   if (!pack.ontologyBindings || pack.ontologyBindings.length === 0) {
     issues.push(
       issue(
@@ -492,6 +499,8 @@ function validateDomainPack(pack) {
       );
     }
   }
+}
+function validateTopicRoots(pack, issues) {
   if (!pack.topicRoots || pack.topicRoots.length === 0) {
     issues.push(
       issue(
@@ -500,270 +509,343 @@ function validateDomainPack(pack) {
         "topicRoots"
       )
     );
-  } else {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(pack.topicRoots, "slug", "topicRoots")
+  );
+}
+function validateOperatingSystemPrompts(operatingSystem, issues) {
+  if (!operatingSystem.prompts) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      operatingSystem.prompts,
+      "promptId",
+      "operatingSystem.prompts"
+    )
+  );
+  for (const [index, prompt] of operatingSystem.prompts.entries()) {
+    issues.push(...validatePromptBinding(prompt, index));
+  }
+}
+function validateOperatingSystemTools(operatingSystem, issues) {
+  if (!operatingSystem.tools) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      operatingSystem.tools,
+      "toolId",
+      "operatingSystem.tools"
+    )
+  );
+  for (const [index, tool] of operatingSystem.tools.entries()) {
+    issues.push(...validateToolBinding(tool, index));
+  }
+}
+function validateOperatingSystemSetupAssets(operatingSystem, issues) {
+  if (!operatingSystem.setupAssets) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      operatingSystem.setupAssets,
+      "assetId",
+      "operatingSystem.setupAssets"
+    )
+  );
+  for (const [index, asset] of operatingSystem.setupAssets.entries()) {
+    issues.push(...validateSetupAsset(asset, index));
+  }
+}
+function validateOperatingSystemTopicTemplates(operatingSystem, knownRootSlugs, issues) {
+  const templateSlugs = /* @__PURE__ */ new Set();
+  if (!operatingSystem.topicTemplates) {
+    return templateSlugs;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      operatingSystem.topicTemplates,
+      "slug",
+      "operatingSystem.topicTemplates"
+    )
+  );
+  for (const template of operatingSystem.topicTemplates) {
+    if (template.slug) {
+      templateSlugs.add(template.slug);
+    }
+  }
+  const knownTopicSlugs = /* @__PURE__ */ new Set([...knownRootSlugs, ...templateSlugs]);
+  for (const [index, template] of operatingSystem.topicTemplates.entries()) {
+    issues.push(...validateTopicTemplate(template, index, knownTopicSlugs));
+  }
+  return templateSlugs;
+}
+function validateOperatingSystemInstallProfiles(operatingSystem, knownRootSlugs, templateSlugs, issues) {
+  if (!operatingSystem.installProfiles) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      operatingSystem.installProfiles,
+      "profileId",
+      "operatingSystem.installProfiles"
+    )
+  );
+  const knownPromptIds = new Set(
+    operatingSystem.prompts?.map((prompt) => prompt.promptId) ?? []
+  );
+  const knownToolIds = new Set(
+    operatingSystem.tools?.map((tool) => tool.toolId) ?? []
+  );
+  const knownAssetIds = new Set(
+    operatingSystem.setupAssets?.map((asset) => asset.assetId) ?? []
+  );
+  const knownTopicSlugs = /* @__PURE__ */ new Set([...knownRootSlugs, ...templateSlugs]);
+  for (const [index, profile] of operatingSystem.installProfiles.entries()) {
     issues.push(
-      ...checkDuplicateIds(
-        pack.topicRoots,
-        "slug",
-        "topicRoots"
+      ...validateInstallProfile(
+        profile,
+        index,
+        knownPromptIds,
+        knownToolIds,
+        knownAssetIds,
+        knownTopicSlugs
       )
     );
   }
-  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
-          )
-        );
-      });
-    }
+}
+function validateOperatingSystem(pack, issues) {
+  if (!pack.operatingSystem) {
+    return;
   }
+  const knownRootSlugs = new Set(
+    pack.topicRoots?.map((topic) => topic.slug) ?? []
+  );
+  validateOperatingSystemPrompts(pack.operatingSystem, issues);
+  validateOperatingSystemTools(pack.operatingSystem, issues);
+  validateOperatingSystemSetupAssets(pack.operatingSystem, issues);
+  const templateSlugs = validateOperatingSystemTopicTemplates(
+    pack.operatingSystem,
+    knownRootSlugs,
+    issues
+  );
+  validateOperatingSystemInstallProfiles(
+    pack.operatingSystem,
+    knownRootSlugs,
+    templateSlugs,
+    issues
+  );
+}
+function validateRoles(pack, issues) {
   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"
-      )
-    );
+    issues.push(...checkOptionalDuplicateIds(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) {
+}
+function validateGates(pack, issues) {
+  if (!pack.gates) {
+    return;
+  }
+  issues.push(...checkOptionalDuplicateIds(pack.gates, "gateId", "gates"));
+  for (const [index, 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[${index}].criteria`,
+          "warning"
+        )
+      );
+      continue;
+    }
     issues.push(
-      ...checkDuplicateIds(
-        pack.gates,
-        "gateId",
-        "gates"
+      ...checkOptionalDuplicateIds(
+        gate.criteria,
+        "criterionId",
+        `gates[${index}].criteria`
       )
     );
-    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`
-          )
-        );
-      }
-    }
   }
+}
+function validateArtifacts(pack, issues) {
   if (pack.artifacts) {
     issues.push(
-      ...checkDuplicateIds(
-        pack.artifacts,
-        "artifactId",
-        "artifacts"
-      )
+      ...checkOptionalDuplicateIds(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`
-                )
-              );
-            }
-          }
-        }
-      }
+}
+function domainPackReferenceSets(pack) {
+  return {
+    knownGateIds: new Set(pack.gates?.map((gate) => gate.gateId) ?? []),
+    knownArtifactIds: new Set(
+      pack.artifacts?.map((artifact) => artifact.artifactId) ?? []
+    ),
+    knownRoleIds: new Set(pack.roles?.map((role) => role.roleId) ?? [])
+  };
+}
+function validateWorkflowGateReferences(workflow, workflowIndex, knownGateIds, issues) {
+  for (const gateId of workflow.gateCheckpoints) {
+    if (!knownGateIds.has(gateId)) {
+      issues.push(
+        issue(
+          "UNKNOWN_GATE_REF",
+          `Workflow "${workflow.workflowId}" references unknown gate "${gateId}"`,
+          `workflows[${workflowIndex}].gateCheckpoints`
+        )
+      );
     }
   }
-  if (pack.inquiryShaping) {
-    if (pack.inquiryShaping.questionTemplates) {
+}
+function validateWorkflowArtifactReferences(workflow, workflowIndex, knownArtifactIds, issues) {
+  for (const artifactId of workflow.requiredArtifacts) {
+    if (!knownArtifactIds.has(artifactId)) {
       issues.push(
-        ...checkDuplicateIds(
-          pack.inquiryShaping.questionTemplates,
-          "templateId",
-          "inquiryShaping.questionTemplates"
+        issue(
+          "UNKNOWN_ARTIFACT_REF",
+          `Workflow "${workflow.workflowId}" references unknown artifact "${artifactId}"`,
+          `workflows[${workflowIndex}].requiredArtifacts`
         )
       );
-      pack.inquiryShaping.questionTemplates.forEach((template, index) => {
-        issues.push(...validateQuestionTemplate(template, index));
-      });
     }
-    if (pack.inquiryShaping.taskTemplates) {
+  }
+}
+function validateWorkflowStepReferences(step, workflowIndex, stepIndex, refs, issues) {
+  for (const roleId of step.requiredRoles) {
+    if (!refs.knownRoleIds.has(roleId)) {
       issues.push(
-        ...checkDuplicateIds(
-          pack.inquiryShaping.taskTemplates,
-          "templateId",
-          "inquiryShaping.taskTemplates"
+        issue(
+          "UNKNOWN_ROLE_REF",
+          `Step "${step.stepId}" references unknown role "${roleId}"`,
+          `workflows[${workflowIndex}].steps[${stepIndex}].requiredRoles`
         )
       );
-      pack.inquiryShaping.taskTemplates.forEach((template, index) => {
-        issues.push(...validateTaskTemplate(template, index));
-      });
     }
-    if (pack.inquiryShaping.frameworkHints) {
+  }
+  if (step.gateId && !refs.knownGateIds.has(step.gateId)) {
+    issues.push(
+      issue(
+        "UNKNOWN_GATE_REF",
+        `Step "${step.stepId}" references unknown gate "${step.gateId}"`,
+        `workflows[${workflowIndex}].steps[${stepIndex}].gateId`
+      )
+    );
+  }
+  for (const artifactId of step.produces ?? []) {
+    if (!refs.knownArtifactIds.has(artifactId)) {
       issues.push(
-        ...checkDuplicateIds(
-          pack.inquiryShaping.frameworkHints.map((hint) => ({
-            frameworkName: hint.frameworkName
-          })),
-          "frameworkName",
-          "inquiryShaping.frameworkHints"
+        issue(
+          "UNKNOWN_ARTIFACT_REF",
+          `Step "${step.stepId}" references unknown artifact "${artifactId}"`,
+          `workflows[${workflowIndex}].steps[${stepIndex}].produces`
         )
       );
-      pack.inquiryShaping.frameworkHints.forEach((hint, index) => {
-        issues.push(...validateFrameworkHint(hint, index));
-      });
     }
   }
+}
+function validateWorkflows(pack, refs, issues) {
+  if (!pack.workflows) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(pack.workflows, "workflowId", "workflows")
+  );
+  for (const [workflowIndex, workflow] of pack.workflows.entries()) {
+    validateWorkflowGateReferences(
+      workflow,
+      workflowIndex,
+      refs.knownGateIds,
+      issues
+    );
+    validateWorkflowArtifactReferences(
+      workflow,
+      workflowIndex,
+      refs.knownArtifactIds,
+      issues
+    );
+    for (const [stepIndex, step] of workflow.steps.entries()) {
+      validateWorkflowStepReferences(
+        step,
+        workflowIndex,
+        stepIndex,
+        refs,
+        issues
+      );
+    }
+  }
+}
+function validateInquiryQuestionTemplates(pack, issues) {
+  if (!pack.inquiryShaping?.questionTemplates) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      pack.inquiryShaping.questionTemplates,
+      "templateId",
+      "inquiryShaping.questionTemplates"
+    )
+  );
+  for (const [
+    index,
+    template
+  ] of pack.inquiryShaping.questionTemplates.entries()) {
+    issues.push(...validateQuestionTemplate(template, index));
+  }
+}
+function validateInquiryTaskTemplates(pack, issues) {
+  if (!pack.inquiryShaping?.taskTemplates) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      pack.inquiryShaping.taskTemplates,
+      "templateId",
+      "inquiryShaping.taskTemplates"
+    )
+  );
+  for (const [index, template] of pack.inquiryShaping.taskTemplates.entries()) {
+    issues.push(...validateTaskTemplate(template, index));
+  }
+}
+function validateInquiryFrameworkHints(pack, issues) {
+  if (!pack.inquiryShaping?.frameworkHints) {
+    return;
+  }
+  issues.push(
+    ...checkDuplicateIds(
+      pack.inquiryShaping.frameworkHints.map((hint) => ({
+        frameworkName: hint.frameworkName
+      })),
+      "frameworkName",
+      "inquiryShaping.frameworkHints"
+    )
+  );
+  for (const [index, hint] of pack.inquiryShaping.frameworkHints.entries()) {
+    issues.push(...validateFrameworkHint(hint, index));
+  }
+}
+function validateInquiryShaping(pack, issues) {
+  validateInquiryQuestionTemplates(pack, issues);
+  validateInquiryTaskTemplates(pack, issues);
+  validateInquiryFrameworkHints(pack, issues);
+}
+function validateDomainPack(pack) {
+  const issues = [];
+  validatePackIdentity(pack, issues);
+  validateOntologyBindings(pack, issues);
+  validateTopicRoots(pack, issues);
+  validateOperatingSystem(pack, issues);
+  validateRoles(pack, issues);
+  validateGates(pack, issues);
+  validateArtifacts(pack, issues);
+  validateWorkflows(pack, domainPackReferenceSets(pack), issues);
+  validateInquiryShaping(pack, issues);
   return {
     valid: issues.filter((i) => i.severity === "error").length === 0,
     issues
@@ -785,7 +867,7 @@ var TASK_PRIORITY_WEIGHT = {
 };
 function dedupeStrings(values) {
   if (!values || values.length === 0) {
-    return void 0;
+    return;
   }
   const normalized = values.map((value) => value.trim()).filter(Boolean);
   return normalized.length > 0 ? Array.from(new Set(normalized)) : void 0;
@@ -858,7 +940,11 @@ function checkDuplicateIds2(items, idField, path) {
     }
     if (seen.has(id)) {
       issues.push(
-        issue2("DUPLICATE_ID", `Duplicate ${idField} "${id}"`, `${path}.${idField}`)
+        issue2(
+          "DUPLICATE_ID",
+          `Duplicate ${idField} "${id}"`,
+          `${path}.${idField}`
+        )
       );
     }
     seen.add(id);
@@ -984,7 +1070,9 @@ function createShapingContributionRegistry(packs = []) {
     }
     const packValidation = validateDomainPack(pack);
     if (!packValidation.valid) {
-      throw new Error(formatRegistrationIssues(pack.packId, packValidation.issues));
+      throw new Error(
+        formatRegistrationIssues(pack.packId, packValidation.issues)
+      );
     }
     const contribution = buildShapingContribution(pack);
     const contributionValidation = validateShapingContribution(contribution);
@@ -1304,7 +1392,13 @@ var DEVELOPER_REASONING_PACK = defineDomainPack({
         questionType: "counterfactual",
         priority: "high",
         template: "What existing behavior or verification path would regress if {{hypothesis}} is false?",
-        whenObjectiveIncludes: ["build", "implement", "add", "extend", "support"]
+        whenObjectiveIncludes: [
+          "build",
+          "implement",
+          "add",
+          "extend",
+          "support"
+        ]
       }
     ],
     taskTemplates: [