@vibe-engineer/artifacts 0.1.0 → 0.2.0

package/dist/{chunk-XQLK7EDB.js → chunk-FCLM65RB.js}

@@ -16,16 +16,16 @@ var ARTIFACT_KINDS = [
   "skill_manifest"
 ];
 var SCHEMA_FILES = {
-  "work_brief": "schemas/work-brief.schema.json",
-  "implementation_plan": "schemas/implementation-plan.schema.json",
-  "verification_delta": "schemas/verification-delta.schema.json",
-  "build_result": "schemas/build-result.schema.json",
-  "ship_packet": "schemas/ship-packet.schema.json",
-  "evidence_packet": "schemas/evidence-packet.schema.json",
-  "agent_registry_entry": "schemas/agent-registry-entry.schema.json",
-  "context_file_header": "schemas/context-file-header.schema.json",
-  "schematic_manifest": "schemas/schematic-manifest.schema.json",
-  "skill_manifest": "schemas/skill-manifest.schema.json"
+  work_brief: "schemas/work-brief.schema.json",
+  implementation_plan: "schemas/implementation-plan.schema.json",
+  verification_delta: "schemas/verification-delta.schema.json",
+  build_result: "schemas/build-result.schema.json",
+  ship_packet: "schemas/ship-packet.schema.json",
+  evidence_packet: "schemas/evidence-packet.schema.json",
+  agent_registry_entry: "schemas/agent-registry-entry.schema.json",
+  context_file_header: "schemas/context-file-header.schema.json",
+  schematic_manifest: "schemas/schematic-manifest.schema.json",
+  skill_manifest: "schemas/skill-manifest.schema.json"
 };
 var packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 function schemaPathForKind(kind) {

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   loadAllSchemas,
   loadSchema,
   schemaPathForKind
-} from "./chunk-XQLK7EDB.js";
+} from "./chunk-FCLM65RB.js";
 
 // src/errors.js
 var ValidationErrorCode = Object.freeze({
@@ -35,7 +35,15 @@ var ValidationErrorCode = Object.freeze({
   MALFORMED_EXTENSION: "MALFORMED_EXTENSION",
   SCHEMA_INTERNAL_ERROR: "SCHEMA_INTERNAL_ERROR"
 });
-function makeValidationError({ artifactPath, artifactKind, schemaId, schemaVersion, pointer, code, message }) {
+function makeValidationError({
+  artifactPath,
+  artifactKind,
+  schemaId,
+  schemaVersion,
+  pointer,
+  code,
+  message
+}) {
   return {
     artifactPath: artifactPath ?? null,
     artifactKind: artifactKind ?? null,
@@ -51,7 +59,25 @@ function makeValidationError({ artifactPath, artifactKind, schemaId, schemaVersi
 import fs from "fs";
 import path from "path";
 import Ajv2020 from "ajv/dist/2020.js";
-var CORE_FIELDS = /* @__PURE__ */ new Set(["schemaVersion", "artifactKind", "artifactId", "title", "createdAt", "updatedAt", "producer", "status", "ownership", "links", "extensions", "description", "tags", "sourceRefs", "approvedBy", "supersessionReason", "retention"]);
+var CORE_FIELDS = /* @__PURE__ */ new Set([
+  "schemaVersion",
+  "artifactKind",
+  "artifactId",
+  "title",
+  "createdAt",
+  "updatedAt",
+  "producer",
+  "status",
+  "ownership",
+  "links",
+  "extensions",
+  "description",
+  "tags",
+  "sourceRefs",
+  "approvedBy",
+  "supersessionReason",
+  "retention"
+]);
 var VERIFICATION_CATALOG_LAYERS = Object.freeze([
   "safety_hooks",
   "typecheck",
@@ -89,9 +115,12 @@ function createContext(data, artifactPath, schema) {
   };
 }
 function ajvErrorPointer(error) {
-  if (error.keyword === "required" && error.params?.missingProperty) return pointerJoin(error.instancePath || "", error.params.missingProperty);
-  if (error.keyword === "additionalProperties" && error.params?.additionalProperty) return pointerJoin(error.instancePath || "", error.params.additionalProperty);
-  if (error.keyword === "propertyNames" && error.params?.propertyName) return pointerJoin(error.instancePath || "", error.params.propertyName);
+  if (error.keyword === "required" && error.params?.missingProperty)
+    return pointerJoin(error.instancePath || "", error.params.missingProperty);
+  if (error.keyword === "additionalProperties" && error.params?.additionalProperty)
+    return pointerJoin(error.instancePath || "", error.params.additionalProperty);
+  if (error.keyword === "propertyNames" && error.params?.propertyName)
+    return pointerJoin(error.instancePath || "", error.params.propertyName);
   return error.instancePath || "";
 }
 function ajvErrorCode(error) {
@@ -121,12 +150,14 @@ function ajvErrorCode(error) {
   }
 }
 function normalizeAjvErrors(ajvErrors, ctx) {
-  return (ajvErrors ?? []).map((error) => makeValidationError({
-    ...ctx,
-    pointer: ajvErrorPointer(error),
-    code: ajvErrorCode(error),
-    message: error.message ?? `Schema validation failed for keyword ${error.keyword}.`
-  }));
+  return (ajvErrors ?? []).map(
+    (error) => makeValidationError({
+      ...ctx,
+      pointer: ajvErrorPointer(error),
+      code: ajvErrorCode(error),
+      message: error.message ?? `Schema validation failed for keyword ${error.keyword}.`
+    })
+  );
 }
 function createAjv() {
   return new Ajv2020({
@@ -162,15 +193,39 @@ function validateVersionAndKind(data, expectedKind, errors, ctx) {
     return;
   }
   if (typeof data.schemaVersion !== "string" || !/^\d+\.\d+\.\d+$/.test(data.schemaVersion)) {
-    addError(errors, ctx, "/schemaVersion", ValidationErrorCode.UNSUPPORTED_VERSION, "schemaVersion must be semantic version 1.0.0.");
+    addError(
+      errors,
+      ctx,
+      "/schemaVersion",
+      ValidationErrorCode.UNSUPPORTED_VERSION,
+      "schemaVersion must be semantic version 1.0.0."
+    );
   } else if (data.schemaVersion !== SUPPORTED_SCHEMA_VERSION) {
-    addError(errors, ctx, "/schemaVersion", ValidationErrorCode.UNSUPPORTED_VERSION, `Unsupported artifact schemaVersion ${data.schemaVersion}.`);
+    addError(
+      errors,
+      ctx,
+      "/schemaVersion",
+      ValidationErrorCode.UNSUPPORTED_VERSION,
+      `Unsupported artifact schemaVersion ${data.schemaVersion}.`
+    );
   }
   if (!ARTIFACT_KINDS.includes(data.artifactKind)) {
-    addError(errors, ctx, "/artifactKind", ValidationErrorCode.ARTIFACT_KIND_MISMATCH, "Unknown artifactKind.");
+    addError(
+      errors,
+      ctx,
+      "/artifactKind",
+      ValidationErrorCode.ARTIFACT_KIND_MISMATCH,
+      "Unknown artifactKind."
+    );
   }
   if (expectedKind && data.artifactKind !== expectedKind) {
-    addError(errors, ctx, "/artifactKind", ValidationErrorCode.ARTIFACT_KIND_MISMATCH, `Expected artifactKind ${expectedKind}.`);
+    addError(
+      errors,
+      ctx,
+      "/artifactKind",
+      ValidationErrorCode.ARTIFACT_KIND_MISMATCH,
+      `Expected artifactKind ${expectedKind}.`
+    );
   }
 }
 function linkMatches(link, rel, artifactKind, requiredStatus) {
@@ -182,12 +237,24 @@ function evidencePacketLinkMatches(link) {
 function requireLink(errors, ctx, pointer, link, rel, artifactKind, requiredStatus) {
   if (!linkMatches(link, rel, artifactKind, requiredStatus)) {
     const statusText = requiredStatus ? ` with statusAtLinkTime ${requiredStatus}` : "";
-    addError(errors, ctx, pointer, ValidationErrorCode.BAD_LINK, `Required ${rel} link to ${artifactKind}${statusText} is missing or malformed.`);
+    addError(
+      errors,
+      ctx,
+      pointer,
+      ValidationErrorCode.BAD_LINK,
+      `Required ${rel} link to ${artifactKind}${statusText} is missing or malformed.`
+    );
   }
 }
 function requireEvidencePacketRef(errors, ctx, pointer, link) {
   if (!evidencePacketLinkMatches(link)) {
-    addError(errors, ctx, pointer, ValidationErrorCode.EVIDENCE_LINK_REQUIRED, "Verification evidence references must be required evidence_for links to evidence_packet artifacts.");
+    addError(
+      errors,
+      ctx,
+      pointer,
+      ValidationErrorCode.EVIDENCE_LINK_REQUIRED,
+      "Verification evidence references must be required evidence_for links to evidence_packet artifacts."
+    );
   }
 }
 function validateVerificationCatalog(data, errors, ctx, basePointer = "") {
@@ -197,31 +264,69 @@ function validateVerificationCatalog(data, errors, ctx, basePointer = "") {
     if (!isObject(item)) return;
     if (typeof item.layer === "string") seen.add(item.layer);
     if (item.action === "not_applicable" && (typeof item.rationale !== "string" || item.rationale.trim() === "")) {
-      addError(errors, ctx, `${basePointer}/requiredItems/${index}/rationale`, ValidationErrorCode.NOT_APPLICABLE_RATIONALE_REQUIRED, "not_applicable verification catalog items require a rationale.");
+      addError(
+        errors,
+        ctx,
+        `${basePointer}/requiredItems/${index}/rationale`,
+        ValidationErrorCode.NOT_APPLICABLE_RATIONALE_REQUIRED,
+        "not_applicable verification catalog items require a rationale."
+      );
     }
     if (item.action === "blocked") {
       if (typeof item.blockedBy !== "string" || item.blockedBy.trim() === "") {
-        addError(errors, ctx, `${basePointer}/requiredItems/${index}/blockedBy`, ValidationErrorCode.BLOCKED_ITEM_METADATA_REQUIRED, "blocked verification catalog items require blockedBy.");
+        addError(
+          errors,
+          ctx,
+          `${basePointer}/requiredItems/${index}/blockedBy`,
+          ValidationErrorCode.BLOCKED_ITEM_METADATA_REQUIRED,
+          "blocked verification catalog items require blockedBy."
+        );
       }
       if (typeof item.unblockCondition !== "string" || item.unblockCondition.trim() === "") {
-        addError(errors, ctx, `${basePointer}/requiredItems/${index}/unblockCondition`, ValidationErrorCode.BLOCKED_ITEM_METADATA_REQUIRED, "blocked verification catalog items require unblockCondition.");
+        addError(
+          errors,
+          ctx,
+          `${basePointer}/requiredItems/${index}/unblockCondition`,
+          ValidationErrorCode.BLOCKED_ITEM_METADATA_REQUIRED,
+          "blocked verification catalog items require unblockCondition."
+        );
       }
     }
   });
   for (const layer of VERIFICATION_CATALOG_LAYERS) {
     if (!seen.has(layer)) {
-      addError(errors, ctx, `${basePointer}/requiredItems`, ValidationErrorCode.VERIFICATION_CATALOG_INCOMPLETE, `Verification Delta must include catalog layer ${layer}.`);
+      addError(
+        errors,
+        ctx,
+        `${basePointer}/requiredItems`,
+        ValidationErrorCode.VERIFICATION_CATALOG_INCOMPLETE,
+        `Verification Delta must include catalog layer ${layer}.`
+      );
     }
   }
 }
 function requireEvidenceForLinks(data, errors, ctx) {
-  if (!Array.isArray(data.links) || !data.links.some((link) => isObject(link) && link.rel === "evidence_for" && link.required === true)) {
-    addError(errors, ctx, "/links", ValidationErrorCode.EVIDENCE_FOR_REQUIRED, "Evidence Packet must include a required top-level evidence_for link.");
+  if (!Array.isArray(data.links) || !data.links.some(
+    (link) => isObject(link) && link.rel === "evidence_for" && link.required === true
+  )) {
+    addError(
+      errors,
+      ctx,
+      "/links",
+      ValidationErrorCode.EVIDENCE_FOR_REQUIRED,
+      "Evidence Packet must include a required top-level evidence_for link."
+    );
   }
   if (!Array.isArray(data.subjectRefs) || data.subjectRefs.length === 0) return;
   data.subjectRefs.forEach((ref, index) => {
     if (!isObject(ref) || ref.rel !== "evidence_for" || ref.required !== true) {
-      addError(errors, ctx, `/subjectRefs/${index}`, ValidationErrorCode.EVIDENCE_FOR_REQUIRED, "Evidence Packet subjectRefs must use required evidence_for links.");
+      addError(
+        errors,
+        ctx,
+        `/subjectRefs/${index}`,
+        ValidationErrorCode.EVIDENCE_FOR_REQUIRED,
+        "Evidence Packet subjectRefs must use required evidence_for links."
+      );
     }
   });
 }
@@ -230,12 +335,24 @@ function semanticChecks(kind, data, errors, ctx) {
   if (isObject(data.extensions)) {
     for (const [namespace, value] of Object.entries(data.extensions)) {
       if (!isObject(value) || typeof value.schemaVersion !== "string") {
-        addError(errors, ctx, `/extensions/${namespace}`, ValidationErrorCode.MALFORMED_EXTENSION, "Extension value must be an object with schemaVersion.");
+        addError(
+          errors,
+          ctx,
+          `/extensions/${namespace}`,
+          ValidationErrorCode.MALFORMED_EXTENSION,
+          "Extension value must be an object with schemaVersion."
+        );
         continue;
       }
       for (const key of Object.keys(value)) {
         if (key !== "schemaVersion" && CORE_FIELDS.has(key)) {
-          addError(errors, ctx, `/extensions/${namespace}/${key}`, ValidationErrorCode.MALFORMED_EXTENSION, `Extension ${namespace} must not redefine core field ${key}.`);
+          addError(
+            errors,
+            ctx,
+            `/extensions/${namespace}/${key}`,
+            ValidationErrorCode.MALFORMED_EXTENSION,
+            `Extension ${namespace} must not redefine core field ${key}.`
+          );
         }
       }
     }
@@ -243,92 +360,238 @@ function semanticChecks(kind, data, errors, ctx) {
   switch (kind) {
     case "work_brief": {
       if (!Array.isArray(data.links) || !data.links.some((link) => linkMatches(link, "raw_intent", "work_brief"))) {
-        addError(errors, ctx, "/links", ValidationErrorCode.BAD_LINK, "Work Brief must include a required raw_intent link.");
+        addError(
+          errors,
+          ctx,
+          "/links",
+          ValidationErrorCode.BAD_LINK,
+          "Work Brief must include a required raw_intent link."
+        );
       }
       break;
     }
     case "implementation_plan": {
-      requireLink(errors, ctx, "/workBriefRef", data.workBriefRef, "derived_from", "work_brief", "ready");
+      requireLink(
+        errors,
+        ctx,
+        "/workBriefRef",
+        data.workBriefRef,
+        "derived_from",
+        "work_brief",
+        "ready"
+      );
       if (data.status === "approved" && Array.isArray(data.openBlockers) && data.openBlockers.some((b) => b?.blocking === true)) {
-        addError(errors, ctx, "/openBlockers", ValidationErrorCode.BAD_STATUS_HANDOFF, "Approved Implementation Plan cannot contain unresolved blocking openBlockers.");
+        addError(
+          errors,
+          ctx,
+          "/openBlockers",
+          ValidationErrorCode.BAD_STATUS_HANDOFF,
+          "Approved Implementation Plan cannot contain unresolved blocking openBlockers."
+        );
       }
       if (data.verificationDelta?.artifactKind !== "verification_delta") {
-        addError(errors, ctx, "/verificationDelta/artifactKind", ValidationErrorCode.BAD_LINK, "Implementation Plan must embed a Verification Delta artifact.");
+        addError(
+          errors,
+          ctx,
+          "/verificationDelta/artifactKind",
+          ValidationErrorCode.BAD_LINK,
+          "Implementation Plan must embed a Verification Delta artifact."
+        );
       } else {
         validateVerificationCatalog(data.verificationDelta, errors, ctx, "/verificationDelta");
       }
       break;
     }
     case "verification_delta": {
-      requireLink(errors, ctx, "/implementationPlanRef", data.implementationPlanRef, "verification_delta_of", "implementation_plan");
+      requireLink(
+        errors,
+        ctx,
+        "/implementationPlanRef",
+        data.implementationPlanRef,
+        "verification_delta_of",
+        "implementation_plan"
+      );
       if (!Array.isArray(data.requiredItems) || data.requiredItems.length === 0) {
-        addError(errors, ctx, "/requiredItems", ValidationErrorCode.REQUIRED, "Verification Delta must include required catalog items.");
+        addError(
+          errors,
+          ctx,
+          "/requiredItems",
+          ValidationErrorCode.REQUIRED,
+          "Verification Delta must include required catalog items."
+        );
       }
       validateVerificationCatalog(data, errors, ctx);
       break;
     }
     case "build_result": {
-      requireLink(errors, ctx, "/implementationPlanRef", data.implementationPlanRef, "implements", "implementation_plan", "approved");
+      requireLink(
+        errors,
+        ctx,
+        "/implementationPlanRef",
+        data.implementationPlanRef,
+        "implements",
+        "implementation_plan",
+        "approved"
+      );
       if (!Array.isArray(data.verificationRuns) || data.verificationRuns.length === 0) {
-        addError(errors, ctx, "/verificationRuns", ValidationErrorCode.REQUIRED, "Build Result must reference Evidence Packets for verification claims.");
+        addError(
+          errors,
+          ctx,
+          "/verificationRuns",
+          ValidationErrorCode.REQUIRED,
+          "Build Result must reference Evidence Packets for verification claims."
+        );
       } else {
-        data.verificationRuns.forEach((run, index) => requireEvidencePacketRef(errors, ctx, `/verificationRuns/${index}/evidencePacketRef`, run?.evidencePacketRef));
+        data.verificationRuns.forEach(
+          (run, index) => requireEvidencePacketRef(
+            errors,
+            ctx,
+            `/verificationRuns/${index}/evidencePacketRef`,
+            run?.evidencePacketRef
+          )
+        );
       }
       if (Array.isArray(data.testsAndVerificationChanged)) {
-        data.testsAndVerificationChanged.forEach((item, index) => requireEvidencePacketRef(errors, ctx, `/testsAndVerificationChanged/${index}/evidenceRef`, item?.evidenceRef));
+        data.testsAndVerificationChanged.forEach(
+          (item, index) => requireEvidencePacketRef(
+            errors,
+            ctx,
+            `/testsAndVerificationChanged/${index}/evidenceRef`,
+            item?.evidenceRef
+          )
+        );
       }
       if (Array.isArray(data.warningsAndBlockers)) {
-        data.warningsAndBlockers.forEach((item, index) => requireEvidencePacketRef(errors, ctx, `/warningsAndBlockers/${index}/evidenceRef`, item?.evidenceRef));
+        data.warningsAndBlockers.forEach(
+          (item, index) => requireEvidencePacketRef(
+            errors,
+            ctx,
+            `/warningsAndBlockers/${index}/evidenceRef`,
+            item?.evidenceRef
+          )
+        );
       }
-      if (data.status === "passed" && Array.isArray(data.warningsAndBlockers) && data.warningsAndBlockers.some((item) => item?.blocking === true && ["critical", "major-local"].includes(item?.severity))) {
-        addError(errors, ctx, "/warningsAndBlockers", ValidationErrorCode.BAD_STATUS_HANDOFF, "Passed Build Result cannot contain blocking critical or major-local evidence.");
+      if (data.status === "passed" && Array.isArray(data.warningsAndBlockers) && data.warningsAndBlockers.some(
+        (item) => item?.blocking === true && ["critical", "major-local"].includes(item?.severity)
+      )) {
+        addError(
+          errors,
+          ctx,
+          "/warningsAndBlockers",
+          ValidationErrorCode.BAD_STATUS_HANDOFF,
+          "Passed Build Result cannot contain blocking critical or major-local evidence."
+        );
       }
       break;
     }
     case "ship_packet": {
-      requireLink(errors, ctx, "/buildResultRef", data.buildResultRef, "ship_packet_of", "build_result", "passed");
+      requireLink(
+        errors,
+        ctx,
+        "/buildResultRef",
+        data.buildResultRef,
+        "ship_packet_of",
+        "build_result",
+        "passed"
+      );
       if (Array.isArray(data.finalVerification)) {
-        data.finalVerification.forEach((item, index) => requireEvidencePacketRef(errors, ctx, `/finalVerification/${index}/evidencePacketRef`, item?.evidencePacketRef));
+        data.finalVerification.forEach(
+          (item, index) => requireEvidencePacketRef(
+            errors,
+            ctx,
+            `/finalVerification/${index}/evidencePacketRef`,
+            item?.evidencePacketRef
+          )
+        );
       }
       if (isObject(data.contextPreservation) && Array.isArray(data.contextPreservation.driftCheckEvidenceRefs)) {
-        data.contextPreservation.driftCheckEvidenceRefs.forEach((ref, index) => requireEvidencePacketRef(errors, ctx, `/contextPreservation/driftCheckEvidenceRefs/${index}`, ref));
+        data.contextPreservation.driftCheckEvidenceRefs.forEach(
+          (ref, index) => requireEvidencePacketRef(
+            errors,
+            ctx,
+            `/contextPreservation/driftCheckEvidenceRefs/${index}`,
+            ref
+          )
+        );
       }
       if (data.noPushWithoutApproval !== true || data.commitPreparation?.commitPerformedByAgent !== false || data.prPreparation?.prOpenedByAgent !== false) {
-        addError(errors, ctx, "/noPushWithoutApproval", ValidationErrorCode.BAD_STATUS_HANDOFF, "Ship Packet must preserve no-push/no-PR-without-approval policy.");
+        addError(
+          errors,
+          ctx,
+          "/noPushWithoutApproval",
+          ValidationErrorCode.BAD_STATUS_HANDOFF,
+          "Ship Packet must preserve no-push/no-PR-without-approval policy."
+        );
       }
       break;
     }
     case "evidence_packet": {
       requireEvidenceForLinks(data, errors, ctx);
       if (["fail", "blocked"].includes(data.result) && !isObject(data.failureDetails)) {
-        addError(errors, ctx, "/failureDetails", ValidationErrorCode.REQUIRED, "Failure or blocked evidence requires failureDetails.");
+        addError(
+          errors,
+          ctx,
+          "/failureDetails",
+          ValidationErrorCode.REQUIRED,
+          "Failure or blocked evidence requires failureDetails."
+        );
       }
       if (data.evidenceClass === "advisory" && data.blocking === true && data.result !== "advisory") {
-        addError(errors, ctx, "/blocking", ValidationErrorCode.BAD_STATUS_HANDOFF, "Advisory evidence cannot masquerade as deterministic blocker.");
+        addError(
+          errors,
+          ctx,
+          "/blocking",
+          ValidationErrorCode.BAD_STATUS_HANDOFF,
+          "Advisory evidence cannot masquerade as deterministic blocker."
+        );
       }
       break;
     }
     case "agent_registry_entry": {
       if (!Array.isArray(data.inputSchemas) || data.inputSchemas.length === 0 || !Array.isArray(data.outputSchemas) || data.outputSchemas.length === 0) {
-        addError(errors, ctx, "/inputSchemas", ValidationErrorCode.REQUIRED, "Agent registry entries require input and output schema refs.");
+        addError(
+          errors,
+          ctx,
+          "/inputSchemas",
+          ValidationErrorCode.REQUIRED,
+          "Agent registry entries require input and output schema refs."
+        );
       }
       break;
     }
     case "context_file_header": {
       if (!isObject(data.driftMetadata) || !isObject(data.updateMetadata)) {
-        addError(errors, ctx, "/driftMetadata", ValidationErrorCode.REQUIRED, "Context headers require update and drift metadata.");
+        addError(
+          errors,
+          ctx,
+          "/driftMetadata",
+          ValidationErrorCode.REQUIRED,
+          "Context headers require update and drift metadata."
+        );
       }
       break;
     }
     case "schematic_manifest": {
       if (!Array.isArray(data.inputs) || data.inputs.length === 0 || !Array.isArray(data.generatedPaths) || data.generatedPaths.length === 0) {
-        addError(errors, ctx, "/inputs", ValidationErrorCode.REQUIRED, "Schematic manifests require input schema refs and generated path policy.");
+        addError(
+          errors,
+          ctx,
+          "/inputs",
+          ValidationErrorCode.REQUIRED,
+          "Schematic manifests require input schema refs and generated path policy."
+        );
       }
       break;
     }
     case "skill_manifest": {
       if (!Array.isArray(data.outputArtifactSchemas) || data.outputArtifactSchemas.length === 0 || !Array.isArray(data.forbiddenActions) || data.forbiddenActions.length === 0) {
-        addError(errors, ctx, "/outputArtifactSchemas", ValidationErrorCode.REQUIRED, "Skill manifests require output schema refs and forbidden action policy.");
+        addError(
+          errors,
+          ctx,
+          "/outputArtifactSchemas",
+          ValidationErrorCode.REQUIRED,
+          "Skill manifests require output schema refs and forbidden action policy."
+        );
       }
       break;
     }
@@ -340,37 +603,100 @@ function validateArtifactKind(kind, data, options = {}) {
   const errors = [];
   const validator = compiledRegistry.compiled.get(kind);
   if (!schema || !validator) {
-    addError(errors, ctx, "", ValidationErrorCode.SCHEMA_INTERNAL_ERROR, `No schema registered for kind ${kind}.`);
+    addError(
+      errors,
+      ctx,
+      "",
+      ValidationErrorCode.SCHEMA_INTERNAL_ERROR,
+      `No schema registered for kind ${kind}.`
+    );
     return { ok: false, errors };
   }
   validateVersionAndKind(data, kind, errors, ctx);
   const schemaOk = validator(data);
   if (!schemaOk) errors.push(...normalizeAjvErrors(validator.errors, ctx));
   semanticChecks(kind, data, errors, ctx);
-  return errors.length === 0 ? { ok: true, artifact: data, kind, schemaId: schema.$id, schemaVersion: SUPPORTED_SCHEMA_VERSION } : { ok: false, errors };
+  return errors.length === 0 ? {
+    ok: true,
+    artifact: data,
+    kind,
+    schemaId: schema.$id,
+    schemaVersion: SUPPORTED_SCHEMA_VERSION
+  } : { ok: false, errors };
 }
 function validateArtifact(data, options = {}) {
   if (!isObject(data)) {
-    const ctx = { artifactPath: options.artifactPath ?? null, artifactKind: null, schemaVersion: null, schemaId: null };
-    return { ok: false, errors: [makeValidationError({ ...ctx, pointer: "", code: ValidationErrorCode.NOT_OBJECT, message: "Artifact must be a JSON object." })] };
+    const ctx = {
+      artifactPath: options.artifactPath ?? null,
+      artifactKind: null,
+      schemaVersion: null,
+      schemaId: null
+    };
+    return {
+      ok: false,
+      errors: [
+        makeValidationError({
+          ...ctx,
+          pointer: "",
+          code: ValidationErrorCode.NOT_OBJECT,
+          message: "Artifact must be a JSON object."
+        })
+      ]
+    };
   }
   const kind = data.artifactKind;
   if (!ARTIFACT_KINDS.includes(kind)) {
     const ctx = createContext(data, options.artifactPath, null);
-    return { ok: false, errors: [makeValidationError({ ...ctx, pointer: "/artifactKind", code: ValidationErrorCode.ARTIFACT_KIND_MISMATCH, message: "Unknown artifactKind." })] };
+    return {
+      ok: false,
+      errors: [
+        makeValidationError({
+          ...ctx,
+          pointer: "/artifactKind",
+          code: ValidationErrorCode.ARTIFACT_KIND_MISMATCH,
+          message: "Unknown artifactKind."
+        })
+      ]
+    };
   }
   return validateArtifactKind(kind, data, options);
 }
 function validateArtifactFile(filePath, options = {}) {
   const artifactPath = options.artifactPath ?? filePath;
   if (path.extname(filePath) !== ".json") {
-    return { ok: false, errors: [makeValidationError({ artifactPath, artifactKind: options.kind ?? null, schemaId: null, schemaVersion: null, pointer: "", code: ValidationErrorCode.CARRIER_NOT_JSON, message: "Canonical artifact carriers must be UTF-8 JSON files; Markdown, YAML, frontmatter, and chat text are not accepted." })] };
+    return {
+      ok: false,
+      errors: [
+        makeValidationError({
+          artifactPath,
+          artifactKind: options.kind ?? null,
+          schemaId: null,
+          schemaVersion: null,
+          pointer: "",
+          code: ValidationErrorCode.CARRIER_NOT_JSON,
+          message: "Canonical artifact carriers must be UTF-8 JSON files; Markdown, YAML, frontmatter, and chat text are not accepted."
+        })
+      ]
+    };
   }
   let parsed;
   try {
     parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
   } catch (error) {
-    return { ok: false, errors: [makeValidationError({ artifactPath, artifactKind: options.kind ?? null, schemaId: null, schemaVersion: null, pointer: "", code: ValidationErrorCode.JSON_PARSE_ERROR, message: `Invalid JSON artifact: ${error.message}` })] };
+    return {
+      ok: false,
+      errors: [
+        makeValidationError({
+          artifactPath,
+          artifactKind: options.kind ?? null,
+          schemaId: null,
+          schemaVersion: null,
+          pointer: "",
+          code: ValidationErrorCode.JSON_PARSE_ERROR,
+          message: `Invalid JSON artifact: ${error.message}`
+        })
+      ]
+    };
   }
   return options.kind ? validateArtifactKind(options.kind, parsed, { artifactPath }) : validateArtifact(parsed, { artifactPath });
 }

package/dist/schema-registry.js

@@ -5,7 +5,7 @@ import {
   loadAllSchemas,
   loadSchema,
   schemaPathForKind
-} from "./chunk-XQLK7EDB.js";
+} from "./chunk-FCLM65RB.js";
 export {
   ARTIFACT_KINDS,
   SCHEMA_FILES,