agent-contracts 0.12.3 → 0.13.0

package/dist/cli.js

@@ -49864,7 +49864,7 @@ var require_dist12 = __commonJS({
     var draft4MetaSchema = require_json_schema_draft_04();
     var META_SUPPORT_DATA = ["/properties"];
     var META_SCHEMA_ID = "http://json-schema.org/draft-04/schema";
-    var Ajv2 = class extends core_1.default {
+    var Ajv3 = class extends core_1.default {
       constructor(opts = {}) {
         super({
           ...opts,
@@ -49889,9 +49889,9 @@ var require_dist12 = __commonJS({
         return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
       }
     };
-    module.exports = exports = Ajv2;
+    module.exports = exports = Ajv3;
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.default = Ajv2;
+    exports.default = Ajv3;
     var core_2 = __require("ajv/dist/core");
     Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
       return core_2.KeywordCxt;
@@ -50088,8 +50088,8 @@ var require_ajv2 = __commonJS({
       log: console.log,
       error: console.error
     };
-    function createAjvInstance(Ajv2, allErrors) {
-      const ajv2 = new Ajv2({
+    function createAjvInstance(Ajv3, allErrors) {
+      const ajv2 = new Ajv3({
         allErrors,
         meta: true,
         messages: true,
@@ -50102,22 +50102,22 @@ var require_ajv2 = __commonJS({
       if (allErrors) {
         (0, ajv_errors_1.default)(ajv2);
       }
-      if (Ajv2 === ajv_1.default) {
+      if (Ajv3 === ajv_1.default) {
         ajv2.addSchema(draft4MetaSchema);
         ajv2.addSchema(draft6MetaSchema);
       }
       return ajv2;
     }
-    function _createAjvInstances(Ajv2) {
+    function _createAjvInstances(Ajv3) {
       let _default;
       let _allErrors;
       return {
         get default() {
-          _default !== null && _default !== void 0 ? _default : _default = createAjvInstance(Ajv2, false);
+          _default !== null && _default !== void 0 ? _default : _default = createAjvInstance(Ajv3, false);
           return _default;
         },
         get allErrors() {
-          _allErrors !== null && _allErrors !== void 0 ? _allErrors : _allErrors = createAjvInstance(Ajv2, true);
+          _allErrors !== null && _allErrors !== void 0 ? _allErrors : _allErrors = createAjvInstance(Ajv3, true);
           return _allErrors;
         }
       };
@@ -50764,10 +50764,34 @@ var WorkflowSchema = z11.object({
 var ComponentsSchema = z12.object({
   schemas: z12.record(z12.string(), z12.record(z12.string(), z12.any())).default({})
 }).passthrough();
+var SCOPE_NODE_TYPES = [
+  "root",
+  "system",
+  "agent",
+  "task",
+  "execution_step",
+  "artifact",
+  "tool",
+  "tool_command",
+  "validation",
+  "handoff_type",
+  "workflow",
+  "workflow_step",
+  "policy",
+  "guardrail",
+  "guardrail_policy",
+  "rule",
+  "escalation_criterion",
+  "prerequisite"
+];
+var ScopeNodeTypeSchema = z12.enum(SCOPE_NODE_TYPES);
 var XExtensionDeclSchema = z12.object({
   type: z12.string(),
   items: z12.string().optional(),
-  description: z12.string().optional()
+  description: z12.string().optional(),
+  scope: z12.array(ScopeNodeTypeSchema).optional(),
+  schema: z12.record(z12.string(), z12.any()).optional(),
+  required: z12.boolean().default(false)
 });
 var DslSchema = z12.object({
   version: z12.literal(1),
@@ -50784,7 +50808,8 @@ var DslSchema = z12.object({
   guardrails: z12.record(z12.string(), GuardrailSchema).default({}),
   guardrail_policies: z12.record(z12.string(), GuardrailPolicySchema).default({}),
   components: ComponentsSchema.default({ schemas: {} }),
-  "x-extensions": z12.record(z12.string(), XExtensionDeclSchema).optional()
+  extensions: z12.record(z12.string(), XExtensionDeclSchema).default({}),
+  extensions_strict: z12.boolean().default(false)
 }).passthrough();
 
 // src/schema/json-schema-utils.ts
@@ -51541,7 +51566,8 @@ var MERGE_SECTIONS = [
   "policies",
   "guardrails",
   "guardrail_policies",
-  "components"
+  "components",
+  "extensions"
 ];
 function mergeDsl(base, project) {
   const hasExtends = typeof project["extends"] === "string";
@@ -51812,6 +51838,7 @@ var resolveCommand = new Command("resolve").description("Resolve DSL (load + mer
 import { Command as Command2 } from "commander";
 
 // src/validator/schema-validator.ts
+import Ajv from "ajv";
 import { z as z15 } from "zod";
 function unwrap(schema) {
   if (schema instanceof z15.ZodOptional) return unwrap(schema.unwrap());
@@ -51873,14 +51900,14 @@ function checkCustomPropsRecursive(data, schema, path) {
   }
   return [];
 }
-function checkXExtensionsKeys(data) {
-  const extensions = data["x-extensions"];
+function checkExtensionsKeys(data) {
+  const extensions = data["extensions"];
   if (typeof extensions !== "object" || extensions === null) return [];
   const diagnostics = [];
   for (const key of Object.keys(extensions)) {
     if (!key.startsWith("x-")) {
       diagnostics.push({
-        path: `x-extensions.${key}`,
+        path: `extensions.${key}`,
         message: `Extension key "${key}" must start with "x-" prefix.`,
         code: "x-extension-key-prefix"
       });
@@ -51914,29 +51941,634 @@ function checkDecisionStepRoutingKey(data) {
   }
   return diagnostics;
 }
-function validateSchema(data) {
-  const result = DslSchema.safeParse(data);
-  if (!result.success) {
-    const diagnostics = result.error.issues.map((issue) => ({
-      path: issue.path.join("."),
-      message: issue.message,
-      code: "schema-validation"
-    }));
-    return { success: false, diagnostics };
+function isRecord4(v2) {
+  return typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
+}
+function* enumerateEntitiesByType(data, nodeType) {
+  switch (nodeType) {
+    case "root":
+      yield { path: "", obj: data };
+      return;
+    case "system": {
+      const sys = data["system"];
+      if (isRecord4(sys)) yield { path: "system", obj: sys };
+      return;
+    }
+    case "agent": {
+      const agents = data["agents"];
+      if (!isRecord4(agents)) return;
+      for (const [id, a3] of Object.entries(agents)) {
+        if (isRecord4(a3)) yield { path: `agents.${id}`, obj: a3 };
+      }
+      return;
+    }
+    case "rule": {
+      const agents = data["agents"];
+      if (!isRecord4(agents)) return;
+      for (const [aid, a3] of Object.entries(agents)) {
+        if (!isRecord4(a3)) continue;
+        const rules = a3["rules"];
+        if (!Array.isArray(rules)) continue;
+        for (let i3 = 0; i3 < rules.length; i3++) {
+          const r3 = rules[i3];
+          if (isRecord4(r3)) yield { path: `agents.${aid}.rules[${i3}]`, obj: r3 };
+        }
+      }
+      return;
+    }
+    case "escalation_criterion": {
+      const agents = data["agents"];
+      if (!isRecord4(agents)) return;
+      for (const [aid, a3] of Object.entries(agents)) {
+        if (!isRecord4(a3)) continue;
+        const esc = a3["escalation_criteria"];
+        if (!Array.isArray(esc)) continue;
+        for (let i3 = 0; i3 < esc.length; i3++) {
+          const e3 = esc[i3];
+          if (isRecord4(e3)) {
+            yield {
+              path: `agents.${aid}.escalation_criteria[${i3}]`,
+              obj: e3
+            };
+          }
+        }
+      }
+      return;
+    }
+    case "prerequisite": {
+      const agents = data["agents"];
+      if (!isRecord4(agents)) return;
+      for (const [aid, a3] of Object.entries(agents)) {
+        if (!isRecord4(a3)) continue;
+        const pre = a3["prerequisites"];
+        if (!Array.isArray(pre)) continue;
+        for (let i3 = 0; i3 < pre.length; i3++) {
+          const p2 = pre[i3];
+          if (isRecord4(p2)) {
+            yield { path: `agents.${aid}.prerequisites[${i3}]`, obj: p2 };
+          }
+        }
+      }
+      return;
+    }
+    case "task": {
+      const tasks = data["tasks"];
+      if (!isRecord4(tasks)) return;
+      for (const [id, t3] of Object.entries(tasks)) {
+        if (isRecord4(t3)) yield { path: `tasks.${id}`, obj: t3 };
+      }
+      return;
+    }
+    case "execution_step": {
+      const tasks = data["tasks"];
+      if (!isRecord4(tasks)) return;
+      for (const [tid, t3] of Object.entries(tasks)) {
+        if (!isRecord4(t3)) continue;
+        const steps = t3["execution_steps"];
+        if (!Array.isArray(steps)) continue;
+        for (let i3 = 0; i3 < steps.length; i3++) {
+          const s2 = steps[i3];
+          if (isRecord4(s2)) {
+            yield {
+              path: `tasks.${tid}.execution_steps[${i3}]`,
+              obj: s2
+            };
+          }
+        }
+      }
+      return;
+    }
+    case "artifact": {
+      const arts = data["artifacts"];
+      if (!isRecord4(arts)) return;
+      for (const [id, a3] of Object.entries(arts)) {
+        if (isRecord4(a3)) yield { path: `artifacts.${id}`, obj: a3 };
+      }
+      return;
+    }
+    case "tool": {
+      const tools = data["tools"];
+      if (!isRecord4(tools)) return;
+      for (const [id, t3] of Object.entries(tools)) {
+        if (isRecord4(t3)) yield { path: `tools.${id}`, obj: t3 };
+      }
+      return;
+    }
+    case "tool_command": {
+      const tools = data["tools"];
+      if (!isRecord4(tools)) return;
+      for (const [tid, t3] of Object.entries(tools)) {
+        if (!isRecord4(t3)) continue;
+        const cmds = t3["commands"];
+        if (!Array.isArray(cmds)) continue;
+        for (let i3 = 0; i3 < cmds.length; i3++) {
+          const c2 = cmds[i3];
+          if (isRecord4(c2)) {
+            yield { path: `tools.${tid}.commands[${i3}]`, obj: c2 };
+          }
+        }
+      }
+      return;
+    }
+    case "validation": {
+      const vals = data["validations"];
+      if (!isRecord4(vals)) return;
+      for (const [id, v2] of Object.entries(vals)) {
+        if (isRecord4(v2)) yield { path: `validations.${id}`, obj: v2 };
+      }
+      return;
+    }
+    case "handoff_type": {
+      const ht = data["handoff_types"];
+      if (!isRecord4(ht)) return;
+      for (const [id, h2] of Object.entries(ht)) {
+        if (isRecord4(h2)) yield { path: `handoff_types.${id}`, obj: h2 };
+      }
+      return;
+    }
+    case "workflow": {
+      const wf = data["workflow"];
+      if (!isRecord4(wf)) return;
+      for (const [id, w2] of Object.entries(wf)) {
+        if (isRecord4(w2)) yield { path: `workflow.${id}`, obj: w2 };
+      }
+      return;
+    }
+    case "workflow_step": {
+      const wf = data["workflow"];
+      if (!isRecord4(wf)) return;
+      for (const [wid, w2] of Object.entries(wf)) {
+        if (!isRecord4(w2)) continue;
+        const steps = w2["steps"];
+        if (!Array.isArray(steps)) continue;
+        for (let i3 = 0; i3 < steps.length; i3++) {
+          const s2 = steps[i3];
+          if (isRecord4(s2)) {
+            yield { path: `workflow.${wid}.steps[${i3}]`, obj: s2 };
+          }
+        }
+      }
+      return;
+    }
+    case "policy": {
+      const pol = data["policies"];
+      if (!isRecord4(pol)) return;
+      for (const [id, p2] of Object.entries(pol)) {
+        if (isRecord4(p2)) yield { path: `policies.${id}`, obj: p2 };
+      }
+      return;
+    }
+    case "guardrail": {
+      const gr = data["guardrails"];
+      if (!isRecord4(gr)) return;
+      for (const [id, g2] of Object.entries(gr)) {
+        if (isRecord4(g2)) yield { path: `guardrails.${id}`, obj: g2 };
+      }
+      return;
+    }
+    case "guardrail_policy": {
+      const gp = data["guardrail_policies"];
+      if (!isRecord4(gp)) return;
+      for (const [id, p2] of Object.entries(gp)) {
+        if (isRecord4(p2)) yield { path: `guardrail_policies.${id}`, obj: p2 };
+      }
+      return;
+    }
+    default:
+      return;
+  }
+}
+function validateDeclaredExtension(parentPath, nodeType, key, val, declMap, diagnostics, ajvInstance, strict) {
+  const path = parentPath ? `${parentPath}.${key}` : key;
+  const decl = declMap[key];
+  if (decl === void 0) {
+    diagnostics.push({
+      path,
+      message: `Extension "${key}" is not declared in extensions.`,
+      code: "undeclared-extension",
+      ...!strict ? { severity: "warning" } : {}
+    });
+    return;
+  }
+  const scope = decl.scope;
+  if (scope && scope.length > 0 && !scope.includes(nodeType)) {
+    diagnostics.push({
+      path,
+      message: `Extension "${key}" is not allowed on ${nodeType} (declared scope: ${scope.join(", ")}).`,
+      code: "extension-scope-mismatch"
+    });
+    return;
+  }
+  if (decl.schema && typeof decl.schema === "object" && decl.schema !== null && Object.keys(decl.schema).length > 0) {
+    try {
+      const validate = ajvInstance.compile(decl.schema);
+      if (!validate(val)) {
+        diagnostics.push({
+          path,
+          message: `Extension "${key}" value does not match declared schema: ${ajvInstance.errorsText(validate.errors)}`,
+          code: "extension-schema-violation"
+        });
+      }
+    } catch (e3) {
+      diagnostics.push({
+        path,
+        message: `Extension "${key}" has invalid JSON Schema in declaration: ${e3 instanceof Error ? e3.message : String(e3)}`,
+        code: "extension-schema-violation"
+      });
+    }
+  }
+}
+function walkExtensionNodes(value, path, nodeType, declMap, diagnostics, ajvInstance, strict) {
+  if (!isRecord4(value)) return;
+  const obj = value;
+  for (const key of Object.keys(obj)) {
+    if (key === "extensions" || key === "extensions_strict" || key === "x-extensions" || key === "x-extensions-strict") {
+      continue;
+    }
+    if (key.startsWith("x-")) {
+      validateDeclaredExtension(
+        path,
+        nodeType,
+        key,
+        obj[key],
+        declMap,
+        diagnostics,
+        ajvInstance,
+        strict
+      );
+    }
+  }
+  switch (nodeType) {
+    case "root": {
+      const sys = obj["system"];
+      if (isRecord4(sys)) {
+        walkExtensionNodes(
+          sys,
+          "system",
+          "system",
+          declMap,
+          diagnostics,
+          ajvInstance,
+          strict
+        );
+      }
+      const agents = obj["agents"];
+      if (isRecord4(agents)) {
+        for (const [id, a3] of Object.entries(agents)) {
+          if (isRecord4(a3)) {
+            walkExtensionNodes(
+              a3,
+              `agents.${id}`,
+              "agent",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const tasks = obj["tasks"];
+      if (isRecord4(tasks)) {
+        for (const [id, t3] of Object.entries(tasks)) {
+          if (isRecord4(t3)) {
+            walkExtensionNodes(
+              t3,
+              `tasks.${id}`,
+              "task",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const artifacts = obj["artifacts"];
+      if (isRecord4(artifacts)) {
+        for (const [id, a3] of Object.entries(artifacts)) {
+          if (isRecord4(a3)) {
+            walkExtensionNodes(
+              a3,
+              `artifacts.${id}`,
+              "artifact",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const tools = obj["tools"];
+      if (isRecord4(tools)) {
+        for (const [id, t3] of Object.entries(tools)) {
+          if (isRecord4(t3)) {
+            walkExtensionNodes(
+              t3,
+              `tools.${id}`,
+              "tool",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const validations = obj["validations"];
+      if (isRecord4(validations)) {
+        for (const [id, v2] of Object.entries(validations)) {
+          if (isRecord4(v2)) {
+            walkExtensionNodes(
+              v2,
+              `validations.${id}`,
+              "validation",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const handoffTypes = obj["handoff_types"];
+      if (isRecord4(handoffTypes)) {
+        for (const [id, h2] of Object.entries(handoffTypes)) {
+          if (isRecord4(h2)) {
+            walkExtensionNodes(
+              h2,
+              `handoff_types.${id}`,
+              "handoff_type",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const workflow = obj["workflow"];
+      if (isRecord4(workflow)) {
+        for (const [id, w2] of Object.entries(workflow)) {
+          if (isRecord4(w2)) {
+            walkExtensionNodes(
+              w2,
+              `workflow.${id}`,
+              "workflow",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const policies = obj["policies"];
+      if (isRecord4(policies)) {
+        for (const [id, p2] of Object.entries(policies)) {
+          if (isRecord4(p2)) {
+            walkExtensionNodes(
+              p2,
+              `policies.${id}`,
+              "policy",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const guardrails = obj["guardrails"];
+      if (isRecord4(guardrails)) {
+        for (const [id, g2] of Object.entries(guardrails)) {
+          if (isRecord4(g2)) {
+            walkExtensionNodes(
+              g2,
+              `guardrails.${id}`,
+              "guardrail",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const guardrailPolicies = obj["guardrail_policies"];
+      if (isRecord4(guardrailPolicies)) {
+        for (const [id, p2] of Object.entries(guardrailPolicies)) {
+          if (isRecord4(p2)) {
+            walkExtensionNodes(
+              p2,
+              `guardrail_policies.${id}`,
+              "guardrail_policy",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      break;
+    }
+    case "agent": {
+      const rules = obj["rules"];
+      if (Array.isArray(rules)) {
+        for (let i3 = 0; i3 < rules.length; i3++) {
+          const r3 = rules[i3];
+          if (isRecord4(r3)) {
+            walkExtensionNodes(
+              r3,
+              `${path}.rules[${i3}]`,
+              "rule",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const esc = obj["escalation_criteria"];
+      if (Array.isArray(esc)) {
+        for (let i3 = 0; i3 < esc.length; i3++) {
+          const e3 = esc[i3];
+          if (isRecord4(e3)) {
+            walkExtensionNodes(
+              e3,
+              `${path}.escalation_criteria[${i3}]`,
+              "escalation_criterion",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      const pre = obj["prerequisites"];
+      if (Array.isArray(pre)) {
+        for (let i3 = 0; i3 < pre.length; i3++) {
+          const p2 = pre[i3];
+          if (isRecord4(p2)) {
+            walkExtensionNodes(
+              p2,
+              `${path}.prerequisites[${i3}]`,
+              "prerequisite",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      break;
+    }
+    case "task": {
+      const steps = obj["execution_steps"];
+      if (Array.isArray(steps)) {
+        for (let i3 = 0; i3 < steps.length; i3++) {
+          const s2 = steps[i3];
+          if (isRecord4(s2)) {
+            walkExtensionNodes(
+              s2,
+              `${path}.execution_steps[${i3}]`,
+              "execution_step",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      break;
+    }
+    case "tool": {
+      const cmds = obj["commands"];
+      if (Array.isArray(cmds)) {
+        for (let i3 = 0; i3 < cmds.length; i3++) {
+          const c2 = cmds[i3];
+          if (isRecord4(c2)) {
+            walkExtensionNodes(
+              c2,
+              `${path}.commands[${i3}]`,
+              "tool_command",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      break;
+    }
+    case "workflow": {
+      const steps = obj["steps"];
+      if (Array.isArray(steps)) {
+        for (let i3 = 0; i3 < steps.length; i3++) {
+          const s2 = steps[i3];
+          if (isRecord4(s2)) {
+            walkExtensionNodes(
+              s2,
+              `${path}.steps[${i3}]`,
+              "workflow_step",
+              declMap,
+              diagnostics,
+              ajvInstance,
+              strict
+            );
+          }
+        }
+      }
+      break;
+    }
+    default:
+      break;
   }
-  const customPropDiagnostics = checkCustomPropsRecursive(data, DslSchema, "");
-  if (customPropDiagnostics.length > 0) {
-    return { success: false, diagnostics: customPropDiagnostics };
+}
+function checkExtensionValidation(data) {
+  const strict = data["extensions_strict"] === true;
+  const raw = data["extensions"];
+  let declMap;
+  if (!isRecord4(raw) || Object.keys(raw).length === 0) {
+    if (!strict) return [];
+    declMap = {};
+  } else {
+    declMap = raw;
+  }
+  const diagnostics = [];
+  const ajvInstance = new Ajv({ allErrors: true, strict: false });
+  walkExtensionNodes(data, "", "root", declMap, diagnostics, ajvInstance, strict);
+  for (const [extKey, decl] of Object.entries(declMap)) {
+    if (!decl.required) continue;
+    const applicableTypes = decl.scope && decl.scope.length > 0 ? decl.scope : [...SCOPE_NODE_TYPES];
+    for (const t3 of applicableTypes) {
+      for (const { path, obj } of enumerateEntitiesByType(data, t3)) {
+        if (!(extKey in obj)) {
+          diagnostics.push({
+            path,
+            message: `Required extension "${extKey}" is missing on ${t3}.`,
+            code: "extension-required-missing"
+          });
+        }
+      }
+    }
   }
-  const decisionDiagnostics = checkDecisionStepRoutingKey(data);
-  if (decisionDiagnostics.length > 0) {
-    return { success: false, diagnostics: decisionDiagnostics };
+  return diagnostics;
+}
+function hasBlockingDiagnostic(diagnostics) {
+  return diagnostics.some((d2) => d2.severity !== "warning");
+}
+function validateSchema(data) {
+  const deprecationWarnings = [];
+  if ("x-extensions" in data && !("extensions" in data)) {
+    data["extensions"] = data["x-extensions"];
+    deprecationWarnings.push({
+      path: "x-extensions",
+      message: '"x-extensions" is deprecated. Use "extensions" instead.',
+      code: "deprecated-property",
+      severity: "warning"
+    });
   }
-  const xExtDiagnostics = checkXExtensionsKeys(data);
-  if (xExtDiagnostics.length > 0) {
-    return { success: false, diagnostics: xExtDiagnostics };
+  if ("x-extensions-strict" in data && !("extensions_strict" in data)) {
+    data["extensions_strict"] = data["x-extensions-strict"];
+    deprecationWarnings.push({
+      path: "x-extensions-strict",
+      message: '"x-extensions-strict" is deprecated. Use "extensions_strict" instead.',
+      code: "deprecated-property",
+      severity: "warning"
+    });
   }
-  return { success: true, data: result.data, diagnostics: [] };
+  const result = DslSchema.safeParse(data);
+  if (!result.success) {
+    const diagnostics2 = [
+      ...deprecationWarnings,
+      ...result.error.issues.map((issue) => ({
+        path: issue.path.join("."),
+        message: issue.message,
+        code: "schema-validation"
+      }))
+    ];
+    return { success: false, diagnostics: diagnostics2 };
+  }
+  const diagnostics = [
+    ...deprecationWarnings,
+    ...checkCustomPropsRecursive(data, DslSchema, ""),
+    ...checkDecisionStepRoutingKey(data),
+    ...checkExtensionsKeys(data),
+    ...checkExtensionValidation(data)
+  ];
+  return {
+    success: !hasBlockingDiagnostic(diagnostics),
+    data: result.data,
+    diagnostics
+  };
 }
 
 // src/validator/reference-resolver.ts
@@ -52244,8 +52876,8 @@ function checkReferences(dsl) {
 }
 
 // src/validator/handoff-schema-validator.ts
-import Ajv from "ajv";
-var ajv = new Ajv({ allErrors: true, strict: false });
+import Ajv2 from "ajv";
+var ajv = new Ajv2({ allErrors: true, strict: false });
 function validateHandoffSchemas(dsl) {
   const diagnostics = [];
   for (const [kind, ht] of Object.entries(dsl.handoff_types)) {
@@ -52280,13 +52912,16 @@ function formatDiagnostics(diagnostics, options) {
 
 // src/cli/commands/validate.ts
 var DIR_DEFAULT2 = "agent-contracts.yaml";
-var validateCommand = new Command2("validate").description("Validate DSL against schema and check references").argument("[dir]", "Path to agent-contracts.yaml", DIR_DEFAULT2).option("-c, --config <path>", "Path to agent-contracts.config.yaml").option("--format <format>", "Output format (text|json)", "text").option("--quiet", "Suppress output on success", false).action(async (dir, opts) => {
+var validateCommand = new Command2("validate").description("Validate DSL against schema and check references").argument("[dir]", "Path to agent-contracts.yaml", DIR_DEFAULT2).option("-c, --config <path>", "Path to agent-contracts.config.yaml").option("--format <format>", "Output format (text|json)", "text").option("--quiet", "Suppress output on success", false).option("--strict", "Treat warnings as errors", false).action(async (dir, opts) => {
   try {
     const config = await loadConfig(opts.config);
     const dslPath = resolveDslPath(dir, DIR_DEFAULT2, config);
     const resolved = await resolve4(dslPath);
     const data = config?.vars ? substituteVars(resolved.data, config.vars) : resolved.data;
     const schemaResult = validateSchema(data);
+    const schemaWarnings = schemaResult.diagnostics.filter(
+      (d2) => d2.severity === "warning"
+    );
     if (!schemaResult.success) {
       const output = formatDiagnostics(schemaResult.diagnostics, opts);
       if (output) process.stderr.write(output + "\n");
@@ -52294,13 +52929,18 @@ var validateCommand = new Command2("validate").description("Validate DSL against
     }
     const refDiags = checkReferences(schemaResult.data);
     const handoffDiags = validateHandoffSchemas(schemaResult.data);
-    const allDiags = [...refDiags, ...handoffDiags];
+    const allDiags = [...refDiags, ...handoffDiags, ...schemaWarnings];
+    const hasWarnings = allDiags.some(
+      (d2) => "severity" in d2 && d2.severity === "warning"
+    );
     if (allDiags.length > 0) {
       const output = formatDiagnostics(allDiags, opts);
       if (output) process.stderr.write(output + "\n");
-      process.exit(1);
+      if (refDiags.length > 0 || handoffDiags.length > 0 || opts.strict && hasWarnings) {
+        process.exit(1);
+      }
     }
-    if (!opts.quiet) {
+    if (!opts.quiet && allDiags.length === 0) {
       process.stdout.write("Validation passed.\n");
     }
   } catch (err) {
@@ -53009,6 +53649,40 @@ var guardrailOrphanedRule = {
   }
 };
 
+// src/linter/rules/validation-executor-no-context.ts
+var validationExecutorNoContextRule = {
+  id: "validation-executor-no-context",
+  description: "Validation executor is not wired so the validation appears in the executor's rendered context",
+  run(dsl) {
+    const diagnostics = [];
+    for (const [validationId, val] of Object.entries(dsl.validations)) {
+      if (val.executor_type === "agent") {
+        const agent = dsl.agents[val.executor];
+        if (!agent) continue;
+        const allowed = new Set(agent.can_perform_validations ?? []);
+        if (!allowed.has(validationId)) {
+          diagnostics.push({
+            ruleId: "validation-executor-no-context",
+            severity: "warning",
+            path: `agents.${val.executor}.can_perform_validations`,
+            message: `Validation "${validationId}" is executed by agent "${val.executor}" but is not listed in can_perform_validations, so it will be missing from that agent's prompt context`
+          });
+        }
+      } else if (val.executor_type === "tool") {
+        if (!dsl.tools[val.executor]) {
+          diagnostics.push({
+            ruleId: "validation-executor-no-context",
+            severity: "warning",
+            path: `validations.${validationId}.executor`,
+            message: `Validation "${validationId}" references tool executor "${val.executor}" which is not defined in tools`
+          });
+        }
+      }
+    }
+    return diagnostics;
+  }
+};
+
 // src/linter/linter.ts
 var builtinRules = [
   validationCoverageRule,
@@ -53024,7 +53698,8 @@ var builtinRules = [
   semanticValidationPhaseCoverageRule,
   entityGuardrailUndefinedRule,
   entityNoGuardrailsRule,
-  guardrailOrphanedRule
+  guardrailOrphanedRule,
+  validationExecutorNoContextRule
 ];
 function lint(dsl, rules = builtinRules) {
   const diagnostics = [];
@@ -53680,6 +54355,9 @@ var lintCommand = new Command3("lint").description("Run semantic lint rules on r
       const resolved = await resolve4(dslPath);
       const data = config?.vars ? substituteVars(resolved.data, config.vars) : resolved.data;
       const schemaResult = validateSchema(data);
+      const schemaWarnings = schemaResult.diagnostics.filter(
+        (d2) => d2.severity === "warning"
+      );
       if (!schemaResult.success) {
         const output = formatDiagnostics(schemaResult.diagnostics, {
           format: opts.format,
@@ -53690,7 +54368,7 @@ var lintCommand = new Command3("lint").description("Run semantic lint rules on r
       }
       const tsDiagnostics = lint(schemaResult.data);
       const spectralDiagnostics = await spectralLint(schemaResult.data);
-      const diagnostics = [...tsDiagnostics, ...spectralDiagnostics];
+      const diagnostics = [...tsDiagnostics, ...spectralDiagnostics, ...schemaWarnings];
       if (diagnostics.length > 0) {
         const output = formatDiagnostics(diagnostics, {
           format: opts.format,
@@ -53813,13 +54491,54 @@ function resolveEffectiveGuardrails(dsl, entityType, entityId) {
   }
   return entries;
 }
+function validationToEntityEntry(validationId, validation) {
+  return {
+    validation_id: validationId,
+    kind: validation.kind,
+    target_artifact: validation.target_artifact,
+    executor_type: validation.executor_type,
+    blocking: validation.blocking,
+    produces_evidence: validation.produces_evidence
+  };
+}
+function resolveEntityValidations(dsl, entityType, entityId) {
+  if (entityType === "agents") {
+    const agent = dsl.agents[entityId];
+    if (!agent) return [];
+    const entries2 = [];
+    for (const vid of agent.can_perform_validations ?? []) {
+      const v2 = dsl.validations[vid];
+      if (v2) entries2.push(validationToEntityEntry(vid, v2));
+    }
+    return entries2;
+  }
+  if (entityType === "tasks") {
+    const task = dsl.tasks[entityId];
+    if (!task) return [];
+    const entries2 = [];
+    for (const vid of task.validations ?? []) {
+      const v2 = dsl.validations[vid];
+      if (v2) entries2.push(validationToEntityEntry(vid, v2));
+    }
+    return entries2;
+  }
+  const entries = [];
+  for (const [vid, v2] of Object.entries(dsl.validations)) {
+    if (v2.executor_type === "tool" && v2.executor === entityId) {
+      entries.push(validationToEntityEntry(vid, v2));
+    }
+  }
+  entries.sort((a3, b3) => a3.validation_id.localeCompare(b3.validation_id));
+  return entries;
+}
 function buildTaskContext(dsl, taskId) {
   const taskDef = dsl.tasks[taskId];
   const task = { ...taskDef, id: taskId };
   const agentDef = dsl.agents[taskDef.target_agent];
   const targetAgent = agentDef ? { ...agentDef, id: taskDef.target_agent } : null;
   const relatedGuardrails = resolveEffectiveGuardrails(dsl, "tasks", taskId);
-  return { task, targetAgent, relatedGuardrails, dsl };
+  const relatedValidations = resolveEntityValidations(dsl, "tasks", taskId);
+  return { task, targetAgent, relatedGuardrails, relatedValidations, dsl };
 }
 function buildArtifactContext(dsl, artifactId) {
   const artifactDef = dsl.artifacts[artifactId];
@@ -53890,12 +54609,14 @@ function buildToolContext(dsl, toolId) {
     return result;
   };
   const relatedGuardrails = resolveEffectiveGuardrails(dsl, "tools", toolId);
+  const relatedValidations = resolveEntityValidations(dsl, "tools", toolId);
   return {
     tool,
     invokableAgents,
     inputArtifactDetails: pickArtifacts(toolDef.input_artifacts),
     outputArtifactDetails: pickArtifacts(toolDef.output_artifacts),
     relatedGuardrails,
+    relatedValidations,
     dsl
   };
 }
@@ -54128,6 +54849,7 @@ function buildPerAgentContext(dsl, agent) {
   const rawReceivableTasks = receivableTasks.map(({ id: _id, ...rest }) => rest);
   const mergedBehavior = mergeBehavioralSpec(agent, rawReceivableTasks);
   const relatedGuardrails = resolveEffectiveGuardrails(dsl, "agents", agentId);
+  const relatedValidations = resolveEntityValidations(dsl, "agents", agentId);
   return {
     agent,
     tasks: receivableTasks,
@@ -54138,6 +54860,7 @@ function buildPerAgentContext(dsl, agent) {
     relatedHandoffTypes,
     mergedBehavior,
     relatedGuardrails,
+    relatedValidations,
     dsl
   };
 }
@@ -55150,6 +55873,9 @@ var checkCommand = new Command5("check").description("Run full pipeline: resolve
       const resolved = await resolve4(config.dsl);
       const data = config.vars ? substituteVars(resolved.data, config.vars) : resolved.data;
       const schemaResult = validateSchema(data);
+      const schemaWarnings = schemaResult.diagnostics.filter(
+        (d2) => d2.severity === "warning"
+      );
       if (!schemaResult.success) {
         const output = formatDiagnostics(schemaResult.diagnostics, {
           format: opts.format,
@@ -55160,7 +55886,7 @@ var checkCommand = new Command5("check").description("Run full pipeline: resolve
       }
       const refDiags = checkReferences(schemaResult.data);
       const handoffDiags = validateHandoffSchemas(schemaResult.data);
-      const allRefDiags = [...refDiags, ...handoffDiags];
+      const allRefDiags = [...refDiags, ...handoffDiags, ...schemaWarnings];
       if (allRefDiags.length > 0) {
         const output = formatDiagnostics(allRefDiags, {
           format: opts.format,