agent-contracts 0.10.0 → 0.11.1

package/dist/cli.js

@@ -159,11 +159,11 @@ function __metadata(metadataKey, metadataValue) {
 }
 function __awaiter(thisArg, _arguments, P2, generator) {
   function adopt(value) {
-    return value instanceof P2 ? value : new P2(function(resolve5) {
-      resolve5(value);
+    return value instanceof P2 ? value : new P2(function(resolve7) {
+      resolve7(value);
     });
   }
-  return new (P2 || (P2 = Promise))(function(resolve5, reject) {
+  return new (P2 || (P2 = Promise))(function(resolve7, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -179,7 +179,7 @@ function __awaiter(thisArg, _arguments, P2, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve5(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve7(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -370,14 +370,14 @@ function __asyncValues(o3) {
   }, i3);
   function verb(n3) {
     i3[n3] = o3[n3] && function(v2) {
-      return new Promise(function(resolve5, reject) {
-        v2 = o3[n3](v2), settle(resolve5, reject, v2.done, v2.value);
+      return new Promise(function(resolve7, reject) {
+        v2 = o3[n3](v2), settle(resolve7, reject, v2.done, v2.value);
       });
     };
   }
-  function settle(resolve5, reject, d2, v2) {
+  function settle(resolve7, reject, d2, v2) {
     Promise.resolve(v2).then(function(v3) {
-      resolve5({ value: v3, done: d2 });
+      resolve7({ value: v3, done: d2 });
     }, reject);
   }
 }
@@ -6293,7 +6293,7 @@ var init_index_es = __esm({
         return { drive: t4.toLowerCase() + ":" };
       }, k2 = function() {
         return { drive: null };
-      }, z15 = function() {
+      }, z17 = function() {
         return { drive: null };
       }, B2 = function(t4) {
         return { protocol: null, origin: null, absolute: false, drive: null, ...t4 };
@@ -6334,7 +6334,7 @@ var init_index_es = __esm({
           var t4, n4, r4, e4, o4;
           return t4 = K2, (n4 = rt()) !== c2 && (r4 = et()) !== c2 && (e4 = ut()) !== c2 && (o4 = it()) !== c2 ? (n4 = s2(n4, r4, e4, o4), t4 = n4) : (K2 = t4, t4 = c2), t4 === c2 && (t4 = K2, (n4 = rt()) !== c2 && (r4 = et()) !== c2 && (e4 = (function() {
             var t5;
-            return (t5 = x3) !== c2 && (t5 = z15()), t5;
+            return (t5 = x3) !== c2 && (t5 = z17()), t5;
           })()) !== c2 ? (n4 = f2(n4, r4, e4), t4 = n4) : (K2 = t4, t4 = c2)), t4;
         })()) === c2 && (n3 = (function() {
           var n4, r4, e4, o4;
@@ -8023,7 +8023,7 @@ __export(index_es_exports2, {
   resolveExternalRef: () => ye,
   resolveExternalRefWithLocation: () => ge,
   resolveInlineRef: () => B,
-  resolveInlineRefWithLocation: () => z14,
+  resolveInlineRefWithLocation: () => z16,
   safeParse: () => de,
   safeStringify: () => ve,
   startsWith: () => be,
@@ -8067,9 +8067,9 @@ function* L(e3, t3, r3) {
   for (const [n3, o3] of t3.entries()) O(e3.value, o3, r3), e3.value = e3.value[o3], A(e3.value) && (j(e3.value), yield [n3, e3.value]);
 }
 function B(e3, t3) {
-  return z14(e3, t3).value;
+  return z16(e3, t3).value;
 }
-function z14(e3, t3) {
+function z16(e3, t3) {
   return (function e4(t4, r3, n3, o3) {
     if (null !== V(r3)) throw new ReferenceError("Cannot resolve external references");
     const i3 = K(r3);
@@ -12937,13 +12937,13 @@ var require_yaml2 = __commonJS({
     function getLocationForJsonPath(result, path) {
       return (0, yaml_1.getLocationForJsonPath)(result, path);
     }
-    var parseYaml3 = (input) => (0, yaml_1.parseWithPointers)(input, {
+    var parseYaml4 = (input) => (0, yaml_1.parseWithPointers)(input, {
       ignoreDuplicateKeys: false,
       mergeKeys: true,
       preserveKeyOrder: true,
       attachComments: false
     });
-    exports.parseYaml = parseYaml3;
+    exports.parseYaml = parseYaml4;
     exports.Yaml = {
       parse: exports.parseYaml,
       getLocationForJsonPath,
@@ -13033,11 +13033,11 @@ function __metadata2(metadataKey, metadataValue) {
 }
 function __awaiter2(thisArg, _arguments, P2, generator) {
   function adopt(value) {
-    return value instanceof P2 ? value : new P2(function(resolve5) {
-      resolve5(value);
+    return value instanceof P2 ? value : new P2(function(resolve7) {
+      resolve7(value);
     });
   }
-  return new (P2 || (P2 = Promise))(function(resolve5, reject) {
+  return new (P2 || (P2 = Promise))(function(resolve7, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -13053,7 +13053,7 @@ function __awaiter2(thisArg, _arguments, P2, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve5(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve7(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -13231,14 +13231,14 @@ function __asyncValues2(o3) {
   }, i3);
   function verb(n3) {
     i3[n3] = o3[n3] && function(v2) {
-      return new Promise(function(resolve5, reject) {
-        v2 = o3[n3](v2), settle(resolve5, reject, v2.done, v2.value);
+      return new Promise(function(resolve7, reject) {
+        v2 = o3[n3](v2), settle(resolve7, reject, v2.done, v2.value);
       });
     };
   }
-  function settle(resolve5, reject, d2, v2) {
+  function settle(resolve7, reject, d2, v2) {
     Promise.resolve(v2).then(function(v3) {
-      resolve5({ value: v3, done: d2 });
+      resolve7({ value: v3, done: d2 });
     }, reject);
   }
 }
@@ -15152,7 +15152,7 @@ function consumeBody() {
   let accum = [];
   let accumBytes = 0;
   let abort = false;
-  return new Body.Promise(function(resolve5, reject) {
+  return new Body.Promise(function(resolve7, reject) {
     let resTimeout;
     if (_this4.timeout) {
       resTimeout = setTimeout(function() {
@@ -15186,7 +15186,7 @@ function consumeBody() {
       }
       clearTimeout(resTimeout);
       try {
-        resolve5(Buffer.concat(accum, accumBytes));
+        resolve7(Buffer.concat(accum, accumBytes));
       } catch (err) {
         reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, "system", err));
       }
@@ -15449,7 +15449,7 @@ function fetch(url, opts) {
     throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
   }
   Body.Promise = fetch.Promise;
-  return new fetch.Promise(function(resolve5, reject) {
+  return new fetch.Promise(function(resolve7, reject) {
     const request = new Request(url, opts);
     const options = getNodeRequestOptions(request);
     const send = (options.protocol === "https:" ? https : http).request;
@@ -15582,7 +15582,7 @@ function fetch(url, opts) {
               requestOpts.body = void 0;
               requestOpts.headers.delete("content-length");
             }
-            resolve5(fetch(new Request(locationURL, requestOpts)));
+            resolve7(fetch(new Request(locationURL, requestOpts)));
             finalize();
             return;
         }
@@ -15603,7 +15603,7 @@ function fetch(url, opts) {
       const codings = headers.get("Content-Encoding");
       if (!request.compress || request.method === "HEAD" || codings === null || res.statusCode === 204 || res.statusCode === 304) {
         response = new Response(body, response_options);
-        resolve5(response);
+        resolve7(response);
         return;
       }
       const zlibOptions = {
@@ -15613,7 +15613,7 @@ function fetch(url, opts) {
       if (codings == "gzip" || codings == "x-gzip") {
         body = body.pipe(zlib.createGunzip(zlibOptions));
         response = new Response(body, response_options);
-        resolve5(response);
+        resolve7(response);
         return;
       }
       if (codings == "deflate" || codings == "x-deflate") {
@@ -15625,12 +15625,12 @@ function fetch(url, opts) {
             body = body.pipe(zlib.createInflateRaw());
           }
           response = new Response(body, response_options);
-          resolve5(response);
+          resolve7(response);
         });
         raw.on("end", function() {
           if (!response) {
             response = new Response(body, response_options);
-            resolve5(response);
+            resolve7(response);
           }
         });
         return;
@@ -15638,11 +15638,11 @@ function fetch(url, opts) {
       if (codings == "br" && typeof zlib.createBrotliDecompress === "function") {
         body = body.pipe(zlib.createBrotliDecompress());
         response = new Response(body, response_options);
-        resolve5(response);
+        resolve7(response);
         return;
       }
       response = new Response(body, response_options);
-      resolve5(response);
+      resolve7(response);
     });
     writeToStream(req, request);
   });
@@ -16355,13 +16355,13 @@ var require_file = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     var fs_1 = __require("fs");
     function resolveFile(ref) {
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve7, reject) => {
         const path = ref.href();
         fs_1.readFile(path, "utf8", (err, data) => {
           if (err) {
             reject(err);
           } else {
-            resolve5(data);
+            resolve7(data);
           }
         });
       });
@@ -16899,7 +16899,7 @@ var require_immer_cjs_production_min = __commonJS({
       var t4 = n4[H2];
       return (t4 ? s2(t4) : n4)[r4];
     }
-    function z15(n4, r4) {
+    function z17(n4, r4) {
       if (r4 in n4) for (var t4 = Object.getPrototypeOf(n4); t4; ) {
         var e4 = Object.getOwnPropertyDescriptor(t4, r4);
         if (e4) return e4;
@@ -17292,7 +17292,7 @@ var require_immer_cjs_production_min = __commonJS({
       if (r4 === H2) return n4;
       var e4 = s2(n4);
       if (!u2(e4, r4)) return (function(n5, r5, t4) {
-        var e5, i5 = z15(r5, t4);
+        var e5, i5 = z17(r5, t4);
         return i5 ? "value" in i5 ? i5.value : null === (e5 = i5.get) || void 0 === e5 ? void 0 : e5.call(n5.k) : void 0;
       })(n4, e4, r4);
       var i4 = e4[r4];
@@ -17302,7 +17302,7 @@ var require_immer_cjs_production_min = __commonJS({
     }, ownKeys: function(n4) {
       return Reflect.ownKeys(s2(n4));
     }, set: function(n4, r4, t4) {
-      var e4 = z15(s2(n4), r4);
+      var e4 = z17(s2(n4), r4);
       if (null == e4 ? void 0 : e4.set) return e4.set.call(n4.k, t4), true;
       if (!n4.g) {
         var i4 = A2(s2(n4), r4), o4 = null == i4 ? void 0 : i4[H2];
@@ -23933,7 +23933,7 @@ var require_reader = __commonJS({
     var lodash_1 = require_lodash();
     var fetch_1 = (0, tslib_1.__importDefault)(require_fetch());
     var printError_1 = require_printError();
-    async function readFile4(name, opts) {
+    async function readFile6(name, opts) {
       if ((0, path_1.isURL)(name)) {
         let response;
         let timeout = null;
@@ -23964,12 +23964,12 @@ var require_reader = __commonJS({
         }
       } else {
         try {
-          return await new Promise((resolve5, reject) => {
+          return await new Promise((resolve7, reject) => {
             fs.readFile(name, opts.encoding, (err, data) => {
               if (err !== null) {
                 reject(err);
               } else {
-                resolve5(data);
+                resolve7(data);
               }
             });
           });
@@ -23978,10 +23978,10 @@ var require_reader = __commonJS({
         }
       }
     }
-    exports.readFile = readFile4;
+    exports.readFile = readFile6;
     async function readParsable(name, opts) {
       try {
-        return await readFile4(name, opts);
+        return await readFile6(name, opts);
       } catch (ex) {
         throw new Error(`Could not parse ${name}: ${(0, printError_1.printError)(ex)}`);
       }
@@ -35641,11 +35641,11 @@ var require_brace_expansion = __commonJS({
             if (pad) {
               var need = width - c2.length;
               if (need > 0) {
-                var z15 = new Array(need + 1).join("0");
+                var z17 = new Array(need + 1).join("0");
                 if (i3 < 0)
-                  c2 = "-" + z15 + c2.slice(1);
+                  c2 = "-" + z17 + c2.slice(1);
                 else
-                  c2 = z15 + c2;
+                  c2 = z17 + c2;
               }
             }
           }
@@ -40854,14 +40854,14 @@ var require_AsyncFromSyncIteratorContinuation = __commonJS({
       if (!$Promise) {
         throw new $SyntaxError("This environment does not support Promises.");
       }
-      return new $Promise(function(resolve5) {
+      return new $Promise(function(resolve7) {
         var done = IteratorComplete(result);
         var value = IteratorValue(result);
         var valueWrapper = PromiseResolve($Promise, value);
         var onFulfilled = function(value2) {
           return CreateIteratorResultObject(value2, done);
         };
-        resolve5($then(valueWrapper, onFulfilled));
+        resolve7($then(valueWrapper, onFulfilled));
       });
     };
   }
@@ -41409,7 +41409,7 @@ var require_CreateAsyncFromSyncIterator = __commonJS({
         var O2 = this;
         SLOT.assert(O2, "[[SyncIteratorRecord]]");
         var argsLength = arguments.length;
-        return new $Promise(function(resolve5) {
+        return new $Promise(function(resolve7) {
           var syncIteratorRecord = SLOT.get(O2, "[[SyncIteratorRecord]]");
           var result;
           if (argsLength > 0) {
@@ -41417,7 +41417,7 @@ var require_CreateAsyncFromSyncIterator = __commonJS({
           } else {
             result = IteratorNext(syncIteratorRecord);
           }
-          resolve5(AsyncFromSyncIteratorContinuation(result));
+          resolve7(AsyncFromSyncIteratorContinuation(result));
         });
       },
       "return": function() {
@@ -41428,12 +41428,12 @@ var require_CreateAsyncFromSyncIterator = __commonJS({
         SLOT.assert(O2, "[[SyncIteratorRecord]]");
         var valueIsPresent = arguments.length > 0;
         var value = valueIsPresent ? arguments[0] : void 0;
-        return new $Promise(function(resolve5, reject) {
+        return new $Promise(function(resolve7, reject) {
           var syncIterator = SLOT.get(O2, "[[SyncIteratorRecord]]")["[[Iterator]]"];
           var iteratorReturn = GetMethod(syncIterator, "return");
           if (typeof iteratorReturn === "undefined") {
             var iterResult = CreateIteratorResultObject(value, true);
-            Call(resolve5, void 0, [iterResult]);
+            Call(resolve7, void 0, [iterResult]);
             return;
           }
           var result;
@@ -41446,7 +41446,7 @@ var require_CreateAsyncFromSyncIterator = __commonJS({
             Call(reject, void 0, [new $TypeError("Iterator `return` method returned a non-object value.")]);
             return;
           }
-          resolve5(AsyncFromSyncIteratorContinuation(result));
+          resolve7(AsyncFromSyncIteratorContinuation(result));
         });
       },
       "throw": function() {
@@ -41457,7 +41457,7 @@ var require_CreateAsyncFromSyncIterator = __commonJS({
         SLOT.assert(O2, "[[SyncIteratorRecord]]");
         var valueIsPresent = arguments.length > 0;
         var value = valueIsPresent ? arguments[0] : void 0;
-        return new $Promise(function(resolve5, reject) {
+        return new $Promise(function(resolve7, reject) {
           var syncIterator = SLOT.get(O2, "[[SyncIteratorRecord]]")["[[Iterator]]"];
           var throwMethod = GetMethod(syncIterator, "throw");
           if (typeof throwMethod === "undefined") {
@@ -41474,7 +41474,7 @@ var require_CreateAsyncFromSyncIterator = __commonJS({
             Call(reject, void 0, [new $TypeError("Iterator `throw` method returned a non-object value.")]);
             return;
           }
-          resolve5(AsyncFromSyncIteratorContinuation(
+          resolve7(AsyncFromSyncIteratorContinuation(
             result
             /* , promiseCapability */
           ));
@@ -49169,7 +49169,7 @@ var require_dist10 = __commonJS({
     var getSiblings = (parent) => (node) => getChildren(parent).filter(not(eq(node)));
     var concatAll = (
       /*::<T>*/
-      (xs) => (ys) => ys.reduce((zs, z15) => zs.concat(z15), xs)
+      (xs) => (ys) => ys.reduce((zs, z17) => zs.concat(z17), xs)
     );
     function getLastSegment(instancePath) {
       const index4 = instancePath.lastIndexOf("/");
@@ -50425,13 +50425,418 @@ var require_dist13 = __commonJS({
 });
 
 // src/cli/cli.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 
 // src/cli/commands/resolve.ts
 import { Command } from "commander";
 
-// src/config/types.ts
+// src/config/binding-loader.ts
+import { readFile as readFile3 } from "fs/promises";
+import { dirname as dirname4, resolve as resolve5 } from "path";
+import { stat as stat2 } from "fs/promises";
+import { parse as parseYaml3 } from "yaml";
+
+// src/schema/agent.ts
 import { z } from "zod";
+var RuleSchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  description: z.string(),
+  severity: z.enum(["mandatory", "recommended", "optional"]),
+  detection_method: z.string().optional(),
+  escalation: z.string().optional(),
+  ref: z.string().optional()
+}).passthrough();
+var EscalationCriterionSchema = z.object({
+  condition: z.string(),
+  action: z.enum([
+    "stop_and_report",
+    "report_to_architect",
+    "wait_for_approval"
+  ])
+}).passthrough();
+var PrerequisiteSchema = z.object({
+  action: z.enum(["read", "execute"]),
+  target: z.string(),
+  required: z.boolean()
+}).passthrough();
+var AgentSchema = z.object({
+  role_name: z.string(),
+  purpose: z.string(),
+  can_read_artifacts: z.array(z.string()).default([]),
+  can_write_artifacts: z.array(z.string()).default([]),
+  can_execute_tools: z.array(z.string()).default([]),
+  can_perform_validations: z.array(z.string()).default([]),
+  can_invoke_agents: z.array(z.string()).default([]),
+  can_return_handoffs: z.array(z.string()).default([]),
+  dispatch_only: z.boolean().optional(),
+  mode: z.enum(["read-only", "read-write"]).optional(),
+  responsibilities: z.array(z.string()).optional(),
+  constraints: z.array(z.string()).optional(),
+  rules: z.array(RuleSchema).optional(),
+  anti_patterns: z.array(z.string()).optional(),
+  escalation_criteria: z.array(EscalationCriterionSchema).optional(),
+  prerequisites: z.array(PrerequisiteSchema).optional()
+}).passthrough();
+
+// src/schema/artifact.ts
+import { z as z2 } from "zod";
+var ArtifactSchema = z2.object({
+  type: z2.string(),
+  description: z2.string().optional(),
+  owner: z2.string(),
+  producers: z2.array(z2.string()),
+  editors: z2.array(z2.string()),
+  consumers: z2.array(z2.string()),
+  states: z2.array(z2.string()),
+  required_validations: z2.array(z2.string()).default([]),
+  visibility: z2.string().optional()
+}).passthrough();
+
+// src/schema/binding.ts
+import { z as z3 } from "zod";
+var CommandRegexMatcherSchema = z3.object({
+  type: z3.literal("command_regex"),
+  pattern: z3.string()
+});
+var ContentRegexMatcherSchema = z3.object({
+  type: z3.literal("content_regex"),
+  pattern: z3.string(),
+  file_glob: z3.string().optional(),
+  exclude_glob: z3.string().optional()
+});
+var FileGlobMatcherSchema = z3.object({
+  type: z3.literal("file_glob"),
+  pattern: z3.string()
+});
+var MatcherSchema = z3.discriminatedUnion("type", [
+  CommandRegexMatcherSchema,
+  ContentRegexMatcherSchema,
+  FileGlobMatcherSchema
+]);
+var CheckSchema = z3.object({
+  matcher: MatcherSchema.optional(),
+  script: z3.string().optional(),
+  message: z3.string().optional()
+}).passthrough();
+var BindingOutputSchema = z3.object({
+  target: z3.string(),
+  template: z3.string().optional(),
+  inline_template: z3.string().optional(),
+  mode: z3.enum(["write", "patch"]).default("write"),
+  group_by: z3.string().optional(),
+  executable: z3.boolean().optional()
+}).passthrough().refine(
+  (data) => !(data.template && data.inline_template),
+  { message: "template and inline_template are mutually exclusive" }
+);
+var ReportingSchema = z3.object({
+  commands: z3.record(z3.string(), z3.string()),
+  fail_open: z3.boolean().default(true),
+  timeout_ms: z3.number().default(5e3)
+}).passthrough();
+var GuardrailImplSchema = z3.object({
+  checks: z3.array(CheckSchema)
+});
+var SoftwareBindingSchema = z3.object({
+  software: z3.string(),
+  version: z3.literal(1),
+  extends: z3.string().optional(),
+  guardrail_impl: z3.record(z3.string(), GuardrailImplSchema).optional(),
+  outputs: z3.record(z3.string(), BindingOutputSchema).optional(),
+  reporting: ReportingSchema.optional()
+}).passthrough();
+
+// src/schema/dsl.ts
+import { z as z12 } from "zod";
+
+// src/schema/handoff-type.ts
+import { z as z4 } from "zod";
+var HandoffTypeSchema = z4.object({
+  version: z4.number(),
+  description: z4.string().optional(),
+  schema: z4.record(z4.string(), z4.any()),
+  example: z4.record(z4.string(), z4.any()).optional()
+}).passthrough();
+
+// src/schema/guardrail.ts
+import { z as z5 } from "zod";
+var GuardrailScopeSchema = z5.object({
+  agents: z5.array(z5.string()).optional(),
+  tasks: z5.array(z5.string()).optional(),
+  tools: z5.array(z5.string()).optional(),
+  artifacts: z5.array(z5.string()).optional(),
+  workflows: z5.array(z5.string()).optional()
+}).passthrough();
+var GuardrailSchema = z5.object({
+  description: z5.string(),
+  scope: GuardrailScopeSchema,
+  rationale: z5.string().optional(),
+  tags: z5.array(z5.string()).default([]),
+  exemptions: z5.array(z5.string()).optional()
+}).passthrough();
+var GuardrailPolicyRuleEscalationSchema = z5.object({
+  target: z5.string(),
+  condition: z5.string().optional()
+}).passthrough();
+var GuardrailPolicyRuleSchema = z5.object({
+  guardrail: z5.string(),
+  severity: z5.enum(["critical", "mandatory", "warning", "info"]),
+  action: z5.enum(["block", "warn", "shadow", "info"]),
+  allow_override: z5.boolean().default(false),
+  override_requires: z5.array(z5.string()).optional(),
+  escalation: GuardrailPolicyRuleEscalationSchema.optional()
+}).passthrough();
+var GuardrailPolicySchema = z5.object({
+  description: z5.string().optional(),
+  rules: z5.array(GuardrailPolicyRuleSchema)
+}).passthrough();
+
+// src/schema/policy.ts
+import { z as z6 } from "zod";
+var PolicyWhenSchema = z6.object({
+  artifact_type: z6.string().optional(),
+  workflow: z6.string().optional()
+}).passthrough();
+var PolicySchema = z6.object({
+  when: PolicyWhenSchema,
+  requires_validations: z6.array(z6.string()).optional(),
+  requires: z6.array(z6.string()).optional()
+}).passthrough();
+
+// src/schema/system.ts
+import { z as z7 } from "zod";
+var VersionLiteralSchema = z7.literal(1);
+var ExtendsSchema = z7.string().optional();
+var SystemSchema = z7.object({
+  id: z7.string(),
+  name: z7.string(),
+  default_workflow_order: z7.array(z7.string())
+}).passthrough();
+
+// src/schema/task.ts
+import { z as z8 } from "zod";
+var ExecutionStepSchema = z8.object({
+  id: z8.string(),
+  action: z8.string(),
+  description: z8.string().optional(),
+  required: z8.boolean().optional(),
+  abort_on_failure: z8.boolean().optional(),
+  uses_tool: z8.string().optional(),
+  produces_artifact: z8.string().optional(),
+  reads_artifact: z8.string().optional(),
+  depends_on: z8.array(z8.string()).optional(),
+  skip_condition: z8.string().optional(),
+  wait_for_approval: z8.boolean().optional()
+}).passthrough();
+var TaskSchema = z8.object({
+  description: z8.string(),
+  target_agent: z8.string(),
+  allowed_from_agents: z8.array(z8.string()),
+  workflow: z8.string(),
+  input_artifacts: z8.array(z8.string()),
+  invocation_handoff: z8.string(),
+  result_handoff: z8.string(),
+  default_priority: z8.string().optional(),
+  responsibilities: z8.array(z8.string()).optional(),
+  constraints: z8.array(z8.string()).optional(),
+  execution_steps: z8.array(ExecutionStepSchema).optional(),
+  completion_criteria: z8.array(z8.string()).optional(),
+  rules: z8.array(RuleSchema).optional(),
+  anti_patterns: z8.array(z8.string()).optional(),
+  escalation_criteria: z8.array(EscalationCriterionSchema).optional(),
+  validations: z8.array(z8.string()).default([])
+}).passthrough();
+
+// src/schema/tool.ts
+import { z as z9 } from "zod";
+var CommandSchema = z9.object({
+  command: z9.string(),
+  category: z9.string(),
+  reads: z9.array(z9.string()).default([]),
+  writes: z9.array(z9.string()).default([]),
+  purpose: z9.string().optional()
+});
+var ToolSchema = z9.object({
+  kind: z9.string(),
+  description: z9.string().optional(),
+  input_artifacts: z9.array(z9.string()).default([]),
+  output_artifacts: z9.array(z9.string()).default([]),
+  invokable_by: z9.array(z9.string()),
+  side_effects: z9.array(z9.string()).default([]),
+  commands: z9.array(CommandSchema).default([])
+}).passthrough();
+
+// src/schema/validation.ts
+import { z as z10 } from "zod";
+var ValidationSchema = z10.object({
+  target_artifact: z10.string(),
+  kind: z10.enum(["schema", "mechanical", "semantic", "approval"]),
+  executor_type: z10.enum(["tool", "agent"]),
+  executor: z10.string(),
+  blocking: z10.boolean(),
+  produces_evidence: z10.string().optional()
+}).passthrough();
+
+// src/schema/workflow.ts
+import { z as z11 } from "zod";
+var RetrySchema = z11.object({
+  condition: z11.string(),
+  fix_task: z11.string(),
+  revalidate_task: z11.string().optional()
+});
+var ExternalParticipantSchema = z11.object({
+  id: z11.string(),
+  kind: z11.enum(["actor", "participant"]),
+  label: z11.string(),
+  description: z11.string().optional()
+});
+var WorkflowDelegateStepSchema = z11.object({
+  type: z11.literal("delegate"),
+  description: z11.string().optional(),
+  task: z11.string(),
+  from_agent: z11.string(),
+  group: z11.string().optional(),
+  retry: RetrySchema.optional()
+}).passthrough();
+var WorkflowGateStepSchema = z11.object({
+  type: z11.literal("gate"),
+  description: z11.string().optional(),
+  gate_kind: z11.string(),
+  group: z11.string().optional()
+}).passthrough();
+var WorkflowHandoffStepSchema = z11.object({
+  type: z11.literal("handoff"),
+  description: z11.string().optional(),
+  handoff_kind: z11.string(),
+  task: z11.string().optional(),
+  from_agent: z11.string().optional(),
+  group: z11.string().optional(),
+  retry: RetrySchema.optional()
+}).passthrough();
+var WorkflowValidationStepSchema = z11.object({
+  type: z11.literal("validation"),
+  description: z11.string().optional(),
+  validation: z11.string(),
+  group: z11.string().optional()
+}).passthrough();
+var WorkflowDecisionStepSchema = z11.object({
+  type: z11.literal("decision"),
+  description: z11.string().optional(),
+  on: z11.string(),
+  branches: z11.record(z11.string(), z11.array(z11.string())),
+  group: z11.string().optional()
+}).passthrough();
+var WorkflowStepSchema = z11.discriminatedUnion("type", [
+  WorkflowDelegateStepSchema,
+  WorkflowGateStepSchema,
+  WorkflowHandoffStepSchema,
+  WorkflowValidationStepSchema,
+  WorkflowDecisionStepSchema
+]);
+var WorkflowSchema = z11.object({
+  description: z11.string().optional(),
+  entry_conditions: z11.array(z11.string()).default([]),
+  trigger: z11.string().optional(),
+  steps: z11.array(WorkflowStepSchema),
+  external_participants: z11.array(ExternalParticipantSchema).default([])
+}).passthrough();
+
+// src/schema/dsl.ts
+var ComponentsSchema = z12.object({
+  schemas: z12.record(z12.string(), z12.record(z12.string(), z12.any())).default({})
+}).passthrough();
+var DslSchema = z12.object({
+  version: z12.literal(1),
+  extends: z12.string().optional(),
+  system: SystemSchema,
+  agents: z12.record(z12.string(), AgentSchema).default({}),
+  tasks: z12.record(z12.string(), TaskSchema).default({}),
+  artifacts: z12.record(z12.string(), ArtifactSchema).default({}),
+  tools: z12.record(z12.string(), ToolSchema).default({}),
+  validations: z12.record(z12.string(), ValidationSchema).default({}),
+  handoff_types: z12.record(z12.string(), HandoffTypeSchema).default({}),
+  workflow: z12.record(z12.string(), WorkflowSchema).default({}),
+  policies: z12.record(z12.string(), PolicySchema).default({}),
+  guardrails: z12.record(z12.string(), GuardrailSchema).default({}),
+  guardrail_policies: z12.record(z12.string(), GuardrailPolicySchema).default({}),
+  components: ComponentsSchema.default({ schemas: {} })
+}).passthrough();
+
+// src/schema/json-schema-utils.ts
+function resolveAllOf(schema) {
+  const allOf = schema["allOf"];
+  if (!Array.isArray(allOf)) return schema;
+  let mergedProperties = {};
+  let mergedRequired = [];
+  const mergedTop = {};
+  for (const sub of allOf) {
+    if (typeof sub !== "object" || sub === null || Array.isArray(sub)) continue;
+    const subSchema = sub;
+    if (subSchema["properties"] && typeof subSchema["properties"] === "object") {
+      mergedProperties = {
+        ...mergedProperties,
+        ...subSchema["properties"]
+      };
+    }
+    if (Array.isArray(subSchema["required"])) {
+      mergedRequired = [
+        ...mergedRequired,
+        ...subSchema["required"]
+      ];
+    }
+    for (const [key, value] of Object.entries(subSchema)) {
+      if (key !== "properties" && key !== "required" && key !== "allOf") {
+        mergedTop[key] = value;
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "allOf") continue;
+    if (key === "properties" && typeof value === "object") {
+      mergedProperties = { ...mergedProperties, ...value };
+    } else if (key === "required" && Array.isArray(value)) {
+      mergedRequired = [...mergedRequired, ...value];
+    } else {
+      mergedTop[key] = value;
+    }
+  }
+  const result = { ...mergedTop };
+  if (Object.keys(mergedProperties).length > 0) {
+    result["properties"] = mergedProperties;
+  }
+  if (mergedRequired.length > 0) {
+    result["required"] = [...new Set(mergedRequired)];
+  }
+  return result;
+}
+
+// src/schema/merge-operators.ts
+import { z as z13 } from "zod";
+var AppendOperatorSchema = z13.object({
+  $append: z13.record(z13.string(), z13.any())
+});
+var PrependOperatorSchema = z13.object({
+  $prepend: z13.record(z13.string(), z13.any())
+});
+var InsertAfterOperatorSchema = z13.object({
+  $insert_after: z13.object({
+    after: z13.string(),
+    entries: z13.record(z13.string(), z13.any())
+  })
+});
+var ReplaceOperatorSchema = z13.object({ $replace: z13.any() });
+var RemoveOperatorSchema = z13.object({
+  $remove: z13.array(z13.string())
+});
+
+// src/config/loader.ts
+import { readFile, access } from "fs/promises";
+import { resolve, dirname } from "path";
+import { parse as parseYaml } from "yaml";
+
+// src/config/types.ts
+import { z as z14 } from "zod";
 var CONTEXT_TYPES = [
   "agent",
   "task",
@@ -50441,18 +50846,20 @@ var CONTEXT_TYPES = [
   "handoff_type",
   "workflow",
   "policy",
+  "guardrail",
+  "guardrail_policy",
   "system"
 ];
-var ContextTypeSchema = z.enum(CONTEXT_TYPES);
+var ContextTypeSchema = z14.enum(CONTEXT_TYPES);
 var ITERABLE_CONTEXT_TYPES = CONTEXT_TYPES.filter(
   (t3) => t3 !== "system"
 );
-var RenderTargetSchema = z.object({
-  template: z.string(),
+var RenderTargetSchema = z14.object({
+  template: z14.string(),
   context: ContextTypeSchema,
-  output: z.string(),
-  include: z.array(z.string()).optional(),
-  exclude: z.array(z.string()).optional()
+  output: z14.string(),
+  include: z14.array(z14.string()).optional(),
+  exclude: z14.array(z14.string()).optional()
 }).refine(
   (data) => !(data.include && data.exclude),
   { message: "include and exclude are mutually exclusive" }
@@ -50465,16 +50872,16 @@ var RenderTargetSchema = z.object({
   },
   { message: "include/exclude cannot be used with context: system" }
 );
-var AgentContractsConfigSchema = z.object({
-  dsl: z.string(),
-  vars: z.record(z.string(), z.string()).optional(),
-  renders: z.array(RenderTargetSchema).min(1)
+var AgentContractsConfigSchema = z14.object({
+  dsl: z14.string(),
+  vars: z14.record(z14.string(), z14.string()).optional(),
+  renders: z14.array(RenderTargetSchema).min(1),
+  bindings: z14.array(z14.string()).default([]),
+  active_guardrail_policy: z14.string().optional(),
+  paths: z14.record(z14.string(), z14.string()).optional()
 });
 
 // src/config/loader.ts
-import { readFile, access } from "fs/promises";
-import { resolve, dirname } from "path";
-import { parse as parseYaml } from "yaml";
 var DEFAULT_CONFIG_NAME = "agent-contracts.config.yaml";
 var ConfigLoadError = class extends Error {
   constructor(message, filePath) {
@@ -50542,7 +50949,10 @@ ${issues}`,
       template: resolve(configDir, r3.template),
       output: resolve(configDir, r3.output)
     })),
-    configDir
+    configDir,
+    bindings: (config.bindings ?? []).map((b3) => resolve(configDir, b3)),
+    activeGuardrailPolicy: config.active_guardrail_policy,
+    paths: config.paths
   };
 }
 function resolveDslPath(dirArg, dirArgDefault, config) {
@@ -51104,6 +51514,8 @@ var MERGE_SECTIONS = [
   "handoff_types",
   "workflow",
   "policies",
+  "guardrails",
+  "guardrail_policies",
   "components"
 ];
 function mergeDsl(base, project) {
@@ -51202,6 +51614,143 @@ function substituteVars(data, vars) {
   return walk(data, vars);
 }
 
+// src/config/binding-merger.ts
+function isRecord3(v2) {
+  return typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
+}
+var BINDING_MERGE_SECTIONS = ["guardrail_impl", "outputs"];
+function mergeBinding(base, project) {
+  const hasExtends = typeof project["extends"] === "string";
+  const result = { ...base, ...project };
+  for (const section of BINDING_MERGE_SECTIONS) {
+    const baseVal = base[section];
+    const projVal = project[section];
+    if (projVal === void 0) {
+      continue;
+    }
+    const baseMap = isRecord3(baseVal) ? baseVal : {};
+    result[section] = mergeEntityMaps(
+      baseMap,
+      projVal,
+      section,
+      hasExtends
+    );
+  }
+  if (project["reporting"] !== void 0 && isRecord3(base["reporting"]) && isRecord3(project["reporting"])) {
+    result["reporting"] = deepMergeEntities(
+      base["reporting"],
+      project["reporting"],
+      "reporting",
+      hasExtends
+    );
+  }
+  delete result["extends"];
+  return result;
+}
+
+// src/config/binding-loader.ts
+async function loadRawBinding(filePath) {
+  let content;
+  try {
+    content = await readFile3(filePath, "utf8");
+  } catch {
+    throw new ConfigLoadError(
+      `Failed to read binding file: ${filePath}`,
+      filePath
+    );
+  }
+  try {
+    return parseYaml3(content);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new ConfigLoadError(
+      `Invalid YAML syntax in binding file ${filePath}: ${msg}`,
+      filePath
+    );
+  }
+}
+async function resolveBindingExtends(raw, filePath, seen) {
+  const extendsValue = raw["extends"];
+  if (typeof extendsValue !== "string") {
+    return raw;
+  }
+  const bindingDir = dirname4(filePath);
+  let basePath;
+  if (extendsValue.startsWith("./") || extendsValue.startsWith("../")) {
+    basePath = resolve5(bindingDir, extendsValue);
+  } else {
+    try {
+      const resolved = import.meta.resolve(extendsValue);
+      basePath = new URL(resolved).pathname;
+    } catch {
+      throw new ConfigLoadError(
+        `Could not resolve binding extends package: ${extendsValue}`,
+        filePath
+      );
+    }
+  }
+  try {
+    const s2 = await stat2(basePath);
+    if (s2.isDirectory()) {
+      const candidates = ["binding.yaml", "binding.yml"];
+      let found = false;
+      for (const name of candidates) {
+        const candidate = resolve5(basePath, name);
+        try {
+          const cs = await stat2(candidate);
+          if (cs.isFile()) {
+            basePath = candidate;
+            found = true;
+            break;
+          }
+        } catch {
+          continue;
+        }
+      }
+      if (!found) {
+        throw new ConfigLoadError(
+          `No binding.yaml found in directory: ${basePath}`,
+          filePath
+        );
+      }
+    }
+  } catch (err) {
+    if (err instanceof ConfigLoadError) throw err;
+    throw new ConfigLoadError(
+      `Base binding path not found: ${basePath}`,
+      filePath
+    );
+  }
+  if (seen.has(basePath)) {
+    throw new ConfigLoadError(
+      `Circular binding extends detected: ${basePath}`,
+      filePath
+    );
+  }
+  seen.add(basePath);
+  const baseRaw = await loadRawBinding(basePath);
+  const resolvedBase = await resolveBindingExtends(baseRaw, basePath, seen);
+  return mergeBinding(resolvedBase, raw);
+}
+async function loadBindings(bindingPaths) {
+  const results = [];
+  for (const filePath of bindingPaths) {
+    const raw = await loadRawBinding(filePath);
+    const merged = await resolveBindingExtends(raw, filePath, /* @__PURE__ */ new Set([filePath]));
+    const result = SoftwareBindingSchema.safeParse(merged);
+    if (!result.success) {
+      const issues = result.error.issues.map((i3) => `  ${i3.path.join(".")}: ${i3.message}`).join("\n");
+      throw new ConfigLoadError(
+        `Invalid binding schema in ${filePath}:
+${issues}`,
+        filePath
+      );
+    }
+    results.push({ filePath, binding: result.data });
+  }
+  return results;
+}
+
 // src/cli/commands/resolve.ts
 import { stringify } from "yaml";
 var DIR_DEFAULT = "agent-contracts.yaml";
@@ -51228,323 +51777,16 @@ var resolveCommand = new Command("resolve").description("Resolve DSL (load + mer
 import { Command as Command2 } from "commander";
 
 // src/validator/schema-validator.ts
-import { z as z13 } from "zod";
-
-// src/schema/agent.ts
-import { z as z2 } from "zod";
-var RuleSchema = z2.object({
-  id: z2.string(),
-  name: z2.string().optional(),
-  description: z2.string(),
-  severity: z2.enum(["mandatory", "recommended", "optional"]),
-  detection_method: z2.string().optional(),
-  escalation: z2.string().optional(),
-  ref: z2.string().optional()
-}).passthrough();
-var EscalationCriterionSchema = z2.object({
-  condition: z2.string(),
-  action: z2.enum([
-    "stop_and_report",
-    "report_to_architect",
-    "wait_for_approval"
-  ])
-}).passthrough();
-var PrerequisiteSchema = z2.object({
-  action: z2.enum(["read", "execute"]),
-  target: z2.string(),
-  required: z2.boolean()
-}).passthrough();
-var AgentSchema = z2.object({
-  role_name: z2.string(),
-  purpose: z2.string(),
-  can_read_artifacts: z2.array(z2.string()).default([]),
-  can_write_artifacts: z2.array(z2.string()).default([]),
-  can_execute_tools: z2.array(z2.string()).default([]),
-  can_perform_validations: z2.array(z2.string()).default([]),
-  can_invoke_agents: z2.array(z2.string()).default([]),
-  can_return_handoffs: z2.array(z2.string()).default([]),
-  dispatch_only: z2.boolean().optional(),
-  mode: z2.enum(["read-only", "read-write"]).optional(),
-  responsibilities: z2.array(z2.string()).optional(),
-  constraints: z2.array(z2.string()).optional(),
-  rules: z2.array(RuleSchema).optional(),
-  anti_patterns: z2.array(z2.string()).optional(),
-  escalation_criteria: z2.array(EscalationCriterionSchema).optional(),
-  prerequisites: z2.array(PrerequisiteSchema).optional()
-}).passthrough();
-
-// src/schema/artifact.ts
-import { z as z3 } from "zod";
-var ArtifactSchema = z3.object({
-  type: z3.string(),
-  description: z3.string().optional(),
-  owner: z3.string(),
-  producers: z3.array(z3.string()),
-  editors: z3.array(z3.string()),
-  consumers: z3.array(z3.string()),
-  states: z3.array(z3.string()),
-  required_validations: z3.array(z3.string()).default([]),
-  visibility: z3.string().optional()
-}).passthrough();
-
-// src/schema/dsl.ts
-import { z as z11 } from "zod";
-
-// src/schema/handoff-type.ts
-import { z as z4 } from "zod";
-var HandoffTypeSchema = z4.object({
-  version: z4.number(),
-  description: z4.string().optional(),
-  schema: z4.record(z4.string(), z4.any()),
-  example: z4.record(z4.string(), z4.any()).optional()
-}).passthrough();
-
-// src/schema/policy.ts
-import { z as z5 } from "zod";
-var PolicyWhenSchema = z5.object({
-  artifact_type: z5.string().optional(),
-  workflow: z5.string().optional()
-}).passthrough();
-var PolicySchema = z5.object({
-  when: PolicyWhenSchema,
-  requires_validations: z5.array(z5.string()).optional(),
-  requires: z5.array(z5.string()).optional()
-}).passthrough();
-
-// src/schema/system.ts
-import { z as z6 } from "zod";
-var VersionLiteralSchema = z6.literal(1);
-var ExtendsSchema = z6.string().optional();
-var SystemSchema = z6.object({
-  id: z6.string(),
-  name: z6.string(),
-  default_workflow_order: z6.array(z6.string())
-}).passthrough();
-
-// src/schema/task.ts
-import { z as z7 } from "zod";
-var ExecutionStepSchema = z7.object({
-  id: z7.string(),
-  action: z7.string(),
-  description: z7.string().optional(),
-  required: z7.boolean().optional(),
-  abort_on_failure: z7.boolean().optional(),
-  uses_tool: z7.string().optional(),
-  produces_artifact: z7.string().optional(),
-  reads_artifact: z7.string().optional(),
-  depends_on: z7.array(z7.string()).optional(),
-  skip_condition: z7.string().optional(),
-  wait_for_approval: z7.boolean().optional()
-}).passthrough();
-var TaskSchema = z7.object({
-  description: z7.string(),
-  target_agent: z7.string(),
-  allowed_from_agents: z7.array(z7.string()),
-  workflow: z7.string(),
-  input_artifacts: z7.array(z7.string()),
-  invocation_handoff: z7.string(),
-  result_handoff: z7.string(),
-  default_priority: z7.string().optional(),
-  responsibilities: z7.array(z7.string()).optional(),
-  constraints: z7.array(z7.string()).optional(),
-  execution_steps: z7.array(ExecutionStepSchema).optional(),
-  completion_criteria: z7.array(z7.string()).optional(),
-  rules: z7.array(RuleSchema).optional(),
-  anti_patterns: z7.array(z7.string()).optional(),
-  escalation_criteria: z7.array(EscalationCriterionSchema).optional(),
-  validations: z7.array(z7.string()).default([])
-}).passthrough();
-
-// src/schema/tool.ts
-import { z as z8 } from "zod";
-var CommandSchema = z8.object({
-  command: z8.string(),
-  category: z8.string(),
-  reads: z8.array(z8.string()).default([]),
-  writes: z8.array(z8.string()).default([]),
-  purpose: z8.string().optional()
-});
-var ToolSchema = z8.object({
-  kind: z8.string(),
-  description: z8.string().optional(),
-  input_artifacts: z8.array(z8.string()).default([]),
-  output_artifacts: z8.array(z8.string()).default([]),
-  invokable_by: z8.array(z8.string()),
-  side_effects: z8.array(z8.string()).default([]),
-  commands: z8.array(CommandSchema).default([])
-}).passthrough();
-
-// src/schema/validation.ts
-import { z as z9 } from "zod";
-var ValidationSchema = z9.object({
-  target_artifact: z9.string(),
-  kind: z9.enum(["schema", "mechanical", "semantic", "approval"]),
-  executor_type: z9.enum(["tool", "agent"]),
-  executor: z9.string(),
-  blocking: z9.boolean(),
-  produces_evidence: z9.string().optional()
-}).passthrough();
-
-// src/schema/workflow.ts
-import { z as z10 } from "zod";
-var RetrySchema = z10.object({
-  condition: z10.string(),
-  fix_task: z10.string(),
-  revalidate_task: z10.string().optional()
-});
-var ExternalParticipantSchema = z10.object({
-  id: z10.string(),
-  kind: z10.enum(["actor", "participant"]),
-  label: z10.string(),
-  description: z10.string().optional()
-});
-var WorkflowDelegateStepSchema = z10.object({
-  type: z10.literal("delegate"),
-  description: z10.string().optional(),
-  task: z10.string(),
-  from_agent: z10.string(),
-  group: z10.string().optional(),
-  retry: RetrySchema.optional()
-}).passthrough();
-var WorkflowGateStepSchema = z10.object({
-  type: z10.literal("gate"),
-  description: z10.string().optional(),
-  gate_kind: z10.string(),
-  group: z10.string().optional()
-}).passthrough();
-var WorkflowHandoffStepSchema = z10.object({
-  type: z10.literal("handoff"),
-  description: z10.string().optional(),
-  handoff_kind: z10.string(),
-  task: z10.string().optional(),
-  from_agent: z10.string().optional(),
-  group: z10.string().optional(),
-  retry: RetrySchema.optional()
-}).passthrough();
-var WorkflowValidationStepSchema = z10.object({
-  type: z10.literal("validation"),
-  description: z10.string().optional(),
-  validation: z10.string(),
-  group: z10.string().optional()
-}).passthrough();
-var WorkflowDecisionStepSchema = z10.object({
-  type: z10.literal("decision"),
-  description: z10.string().optional(),
-  on: z10.string(),
-  branches: z10.record(z10.string(), z10.array(z10.string())),
-  group: z10.string().optional()
-}).passthrough();
-var WorkflowStepSchema = z10.discriminatedUnion("type", [
-  WorkflowDelegateStepSchema,
-  WorkflowGateStepSchema,
-  WorkflowHandoffStepSchema,
-  WorkflowValidationStepSchema,
-  WorkflowDecisionStepSchema
-]);
-var WorkflowSchema = z10.object({
-  description: z10.string().optional(),
-  entry_conditions: z10.array(z10.string()).default([]),
-  trigger: z10.string().optional(),
-  steps: z10.array(WorkflowStepSchema),
-  external_participants: z10.array(ExternalParticipantSchema).default([])
-}).passthrough();
-
-// src/schema/dsl.ts
-var ComponentsSchema = z11.object({
-  schemas: z11.record(z11.string(), z11.record(z11.string(), z11.any())).default({})
-}).passthrough();
-var DslSchema = z11.object({
-  version: z11.literal(1),
-  extends: z11.string().optional(),
-  system: SystemSchema,
-  agents: z11.record(z11.string(), AgentSchema).default({}),
-  tasks: z11.record(z11.string(), TaskSchema).default({}),
-  artifacts: z11.record(z11.string(), ArtifactSchema).default({}),
-  tools: z11.record(z11.string(), ToolSchema).default({}),
-  validations: z11.record(z11.string(), ValidationSchema).default({}),
-  handoff_types: z11.record(z11.string(), HandoffTypeSchema).default({}),
-  workflow: z11.record(z11.string(), WorkflowSchema).default({}),
-  policies: z11.record(z11.string(), PolicySchema).default({}),
-  components: ComponentsSchema.default({ schemas: {} })
-}).passthrough();
-
-// src/schema/json-schema-utils.ts
-function resolveAllOf(schema) {
-  const allOf = schema["allOf"];
-  if (!Array.isArray(allOf)) return schema;
-  let mergedProperties = {};
-  let mergedRequired = [];
-  const mergedTop = {};
-  for (const sub of allOf) {
-    if (typeof sub !== "object" || sub === null || Array.isArray(sub)) continue;
-    const subSchema = sub;
-    if (subSchema["properties"] && typeof subSchema["properties"] === "object") {
-      mergedProperties = {
-        ...mergedProperties,
-        ...subSchema["properties"]
-      };
-    }
-    if (Array.isArray(subSchema["required"])) {
-      mergedRequired = [
-        ...mergedRequired,
-        ...subSchema["required"]
-      ];
-    }
-    for (const [key, value] of Object.entries(subSchema)) {
-      if (key !== "properties" && key !== "required" && key !== "allOf") {
-        mergedTop[key] = value;
-      }
-    }
-  }
-  for (const [key, value] of Object.entries(schema)) {
-    if (key === "allOf") continue;
-    if (key === "properties" && typeof value === "object") {
-      mergedProperties = { ...mergedProperties, ...value };
-    } else if (key === "required" && Array.isArray(value)) {
-      mergedRequired = [...mergedRequired, ...value];
-    } else {
-      mergedTop[key] = value;
-    }
-  }
-  const result = { ...mergedTop };
-  if (Object.keys(mergedProperties).length > 0) {
-    result["properties"] = mergedProperties;
-  }
-  if (mergedRequired.length > 0) {
-    result["required"] = [...new Set(mergedRequired)];
-  }
-  return result;
-}
-
-// src/schema/merge-operators.ts
-import { z as z12 } from "zod";
-var AppendOperatorSchema = z12.object({
-  $append: z12.record(z12.string(), z12.any())
-});
-var PrependOperatorSchema = z12.object({
-  $prepend: z12.record(z12.string(), z12.any())
-});
-var InsertAfterOperatorSchema = z12.object({
-  $insert_after: z12.object({
-    after: z12.string(),
-    entries: z12.record(z12.string(), z12.any())
-  })
-});
-var ReplaceOperatorSchema = z12.object({ $replace: z12.any() });
-var RemoveOperatorSchema = z12.object({
-  $remove: z12.array(z12.string())
-});
-
-// src/validator/schema-validator.ts
+import { z as z15 } from "zod";
 function unwrap(schema) {
-  if (schema instanceof z13.ZodOptional) return unwrap(schema.unwrap());
-  if (schema instanceof z13.ZodDefault) return unwrap(schema.removeDefault());
-  if (schema instanceof z13.ZodNullable) return unwrap(schema.unwrap());
+  if (schema instanceof z15.ZodOptional) return unwrap(schema.unwrap());
+  if (schema instanceof z15.ZodDefault) return unwrap(schema.removeDefault());
+  if (schema instanceof z15.ZodNullable) return unwrap(schema.unwrap());
   return schema;
 }
 function checkCustomPropsRecursive(data, schema, path) {
   const inner = unwrap(schema);
-  if (inner instanceof z13.ZodObject) {
+  if (inner instanceof z15.ZodObject) {
     if (typeof data !== "object" || data === null || Array.isArray(data)) return [];
     const obj = data;
     const shape = inner.shape;
@@ -51565,7 +51807,7 @@ function checkCustomPropsRecursive(data, schema, path) {
     }
     return diagnostics;
   }
-  if (inner instanceof z13.ZodRecord) {
+  if (inner instanceof z15.ZodRecord) {
     if (typeof data !== "object" || data === null || Array.isArray(data)) return [];
     const valueSchema = inner._def.valueType;
     const diagnostics = [];
@@ -51574,7 +51816,7 @@ function checkCustomPropsRecursive(data, schema, path) {
     }
     return diagnostics;
   }
-  if (inner instanceof z13.ZodArray) {
+  if (inner instanceof z15.ZodArray) {
     if (!Array.isArray(data)) return [];
     const diagnostics = [];
     for (let i3 = 0; i3 < data.length; i3++) {
@@ -51582,14 +51824,14 @@ function checkCustomPropsRecursive(data, schema, path) {
     }
     return diagnostics;
   }
-  if (inner instanceof z13.ZodDiscriminatedUnion) {
+  if (inner instanceof z15.ZodDiscriminatedUnion) {
     if (typeof data !== "object" || data === null) return [];
     const obj = data;
     const disc = inner._def.discriminator;
     const discValue = obj[disc];
     const match = inner.options.find((opt) => {
       const shape = opt.shape;
-      return shape[disc] instanceof z13.ZodLiteral && shape[disc].value === discValue;
+      return shape[disc] instanceof z15.ZodLiteral && shape[disc].value === discValue;
     });
     if (match) return checkCustomPropsRecursive(data, match, path);
     return [];
@@ -51623,12 +51865,13 @@ function checkReferences(dsl) {
   const handoffKinds = new Set(Object.keys(dsl.handoff_types));
   const taskIds = new Set(Object.keys(dsl.tasks));
   const workflowIds = new Set(dsl.system.default_workflow_order);
-  function checkExists(value, validSet, entityType, path) {
+  const guardrailIds = new Set(Object.keys(dsl.guardrails));
+  function checkExists(value, validSet, entityType, path, code = "reference-not-found") {
     if (!validSet.has(value)) {
       diagnostics.push({
         path,
         message: `Reference "${value}" not found in ${entityType}`,
-        code: "reference-not-found"
+        code
       });
     }
   }
@@ -51816,6 +52059,75 @@ function checkReferences(dsl) {
       }
     }
   }
+  for (const [id, guardrail] of Object.entries(dsl.guardrails)) {
+    if (guardrail.scope.agents) {
+      for (const ref of guardrail.scope.agents) {
+        checkExists(
+          ref,
+          agentIds,
+          "agents",
+          `guardrails.${id}.scope.agents`,
+          "guardrail-scope-ref-not-found"
+        );
+      }
+    }
+    if (guardrail.scope.tasks) {
+      for (const ref of guardrail.scope.tasks) {
+        checkExists(
+          ref,
+          taskIds,
+          "tasks",
+          `guardrails.${id}.scope.tasks`,
+          "guardrail-scope-ref-not-found"
+        );
+      }
+    }
+    if (guardrail.scope.tools) {
+      for (const ref of guardrail.scope.tools) {
+        checkExists(
+          ref,
+          toolIds,
+          "tools",
+          `guardrails.${id}.scope.tools`,
+          "guardrail-scope-ref-not-found"
+        );
+      }
+    }
+    if (guardrail.scope.artifacts) {
+      for (const ref of guardrail.scope.artifacts) {
+        checkExists(
+          ref,
+          artifactIds,
+          "artifacts",
+          `guardrails.${id}.scope.artifacts`,
+          "guardrail-scope-ref-not-found"
+        );
+      }
+    }
+    if (guardrail.scope.workflows) {
+      for (const ref of guardrail.scope.workflows) {
+        checkExists(
+          ref,
+          workflowIds,
+          "system.default_workflow_order",
+          `guardrails.${id}.scope.workflows`,
+          "guardrail-scope-ref-not-found"
+        );
+      }
+    }
+  }
+  for (const [policyId, policy] of Object.entries(dsl.guardrail_policies)) {
+    for (let i3 = 0; i3 < policy.rules.length; i3++) {
+      const rule = policy.rules[i3];
+      checkExists(
+        rule.guardrail,
+        guardrailIds,
+        "guardrails",
+        `guardrail_policies.${policyId}.rules[${i3}].guardrail`,
+        "guardrail-policy-ref-not-found"
+      );
+    }
+  }
   return diagnostics;
 }
 
@@ -52239,6 +52551,32 @@ var toolCommandsRule = {
   }
 };
 
+// src/linter/rules/guardrail-policy-coverage.ts
+var guardrailPolicyCoverageRule = {
+  id: "guardrail-no-policy-rule",
+  description: "Every guardrail should be referenced by at least one policy rule in guardrail_policies",
+  run(dsl) {
+    const diagnostics = [];
+    const referencedGuardrails = /* @__PURE__ */ new Set();
+    for (const policy of Object.values(dsl.guardrail_policies)) {
+      for (const rule of policy.rules) {
+        referencedGuardrails.add(rule.guardrail);
+      }
+    }
+    for (const guardrailId of Object.keys(dsl.guardrails)) {
+      if (!referencedGuardrails.has(guardrailId)) {
+        diagnostics.push({
+          ruleId: "guardrail-no-policy-rule",
+          severity: "warning",
+          path: `guardrails.${guardrailId}`,
+          message: `Guardrail "${guardrailId}" is not referenced by any policy rule in guardrail_policies`
+        });
+      }
+    }
+    return diagnostics;
+  }
+};
+
 // src/linter/linter.ts
 var builtinRules = [
   validationCoverageRule,
@@ -52246,7 +52584,8 @@ var builtinRules = [
   taskAgentBindingRule,
   mergeIntegrityRule,
   artifactOwnershipRule,
-  toolCommandsRule
+  toolCommandsRule,
+  guardrailPolicyCoverageRule
 ];
 function lint(dsl, rules = builtinRules) {
   const diagnostics = [];
@@ -52941,8 +53280,8 @@ var lintCommand = new Command3("lint").description("Run semantic lint rules on r
 import { Command as Command4 } from "commander";
 
 // src/renderer/renderer.ts
-import { readFile as readFile3, writeFile, mkdir } from "fs/promises";
-import { dirname as dirname4 } from "path";
+import { readFile as readFile4, writeFile, mkdir } from "fs/promises";
+import { dirname as dirname5 } from "path";
 import Handlebars from "handlebars";
 
 // src/renderer/context.ts
@@ -53154,6 +53493,16 @@ function buildPolicyContext(dsl, policyId) {
   const policy = { ...policyDef, id: policyId };
   return { policy, dsl };
 }
+function buildGuardrailContext(dsl, guardrailId) {
+  const guardrailDef = dsl.guardrails[guardrailId];
+  const guardrail = { ...guardrailDef, id: guardrailId };
+  return { guardrail, dsl };
+}
+function buildGuardrailPolicyContext(dsl, policyId) {
+  const policyDef = dsl.guardrail_policies[policyId];
+  const guardrail_policy = { ...policyDef, id: policyId };
+  return { guardrail_policy, dsl };
+}
 function mergeRules(agentRules, taskRules) {
   const result = [...agentRules];
   const existingIds = new Set(result.map((r3) => r3["id"]));
@@ -54001,7 +54350,9 @@ function getDslSection(dsl, context) {
     validation: dsl.validations,
     handoff_type: dsl.handoff_types,
     workflow: dsl.workflow,
-    policy: dsl.policies
+    policy: dsl.policies,
+    guardrail: dsl.guardrails,
+    guardrail_policy: dsl.guardrail_policies
   };
   return sectionMap[context] ?? {};
 }
@@ -54034,12 +54385,16 @@ function buildEntityContext(dsl, context, entityId) {
       return buildWorkflowContext(dsl, entityId);
     case "policy":
       return buildPolicyContext(dsl, entityId);
+    case "guardrail":
+      return buildGuardrailContext(dsl, entityId);
+    case "guardrail_policy":
+      return buildGuardrailPolicyContext(dsl, entityId);
     case "system":
       return buildSystemContext(dsl);
   }
 }
 async function loadTemplate(templatePath) {
-  return readFile3(templatePath, "utf8");
+  return readFile4(templatePath, "utf8");
 }
 async function renderFromConfig(dsl, renderTargets) {
   const outputFiles = [];
@@ -54049,7 +54404,7 @@ async function renderFromConfig(dsl, renderTargets) {
     if (target.context === "system") {
       const ctx = buildSystemContext(dsl);
       const output = compiled(ctx);
-      await mkdir(dirname4(target.output), { recursive: true });
+      await mkdir(dirname5(target.output), { recursive: true });
       await writeFile(target.output, output, "utf8");
       outputFiles.push(target.output);
     } else {
@@ -54060,7 +54415,7 @@ async function renderFromConfig(dsl, renderTargets) {
         const ctx = buildEntityContext(dsl, target.context, entityId);
         const output = compiled(ctx);
         const outputPath = expandOutputPath(target.output, target.context, entityId);
-        await mkdir(dirname4(outputPath), { recursive: true });
+        await mkdir(dirname5(outputPath), { recursive: true });
         await writeFile(outputPath, output, "utf8");
         outputFiles.push(outputPath);
       }
@@ -54077,7 +54432,7 @@ async function checkDriftFromConfig(dsl, renderTargets) {
       const ctx = buildSystemContext(dsl);
       const expected = compiled(ctx);
       try {
-        const existing = await readFile3(target.output, "utf8");
+        const existing = await readFile4(target.output, "utf8");
         if (existing !== expected) diffs.push(target.output);
       } catch {
         diffs.push(target.output);
@@ -54091,7 +54446,7 @@ async function checkDriftFromConfig(dsl, renderTargets) {
         const expected = compiled(ctx);
         const outputPath = expandOutputPath(target.output, target.context, entityId);
         try {
-          const existing = await readFile3(outputPath, "utf8");
+          const existing = await readFile4(outputPath, "utf8");
           if (existing !== expected) diffs.push(outputPath);
         } catch {
           diffs.push(outputPath);
@@ -54249,14 +54604,322 @@ var checkCommand = new Command5("check").description("Run full pipeline: resolve
   }
 );
 
+// src/cli/commands/generate-guardrails.ts
+import { Command as Command6 } from "commander";
+
+// src/guardrail-generator/generator.ts
+import { readFile as readFile5, writeFile as writeFile2, mkdir as mkdir2, chmod } from "fs/promises";
+import { resolve as resolve6, dirname as dirname6 } from "path";
+import Handlebars2 from "handlebars";
+
+// src/guardrail-generator/resolve-checks.ts
+function resolveChecks(dsl, binding, policy) {
+  const resolved = [];
+  const diagnostics = [];
+  const guardrailImpl = binding.guardrail_impl ?? {};
+  for (const [guardrailId, impl] of Object.entries(guardrailImpl)) {
+    const guardrail = dsl.guardrails[guardrailId];
+    if (!guardrail) {
+      diagnostics.push({
+        path: `binding.${binding.software}.guardrail_impl.${guardrailId}`,
+        message: `Binding "${binding.software}" implements guardrail "${guardrailId}" which is not defined in the DSL`,
+        severity: "error"
+      });
+      continue;
+    }
+    const policyRule = policy.rules.find((r3) => r3.guardrail === guardrailId);
+    if (!policyRule) {
+      diagnostics.push({
+        path: `binding.${binding.software}.guardrail_impl.${guardrailId}`,
+        message: `Guardrail "${guardrailId}" has no policy rule in the active policy \u2014 skipping`,
+        severity: "info"
+      });
+      continue;
+    }
+    for (const check of impl.checks) {
+      resolved.push({
+        guardrail_id: guardrailId,
+        guardrail,
+        policy_rule: policyRule,
+        check
+      });
+    }
+  }
+  return { resolved, diagnostics };
+}
+
+// src/guardrail-generator/resolve-paths.ts
+function resolveBindingTargetPath(target, paths, bindingSoftware) {
+  const diagnostics = [];
+  const resolved = target.replace(/\{(\w+)\}/g, (match, varName) => {
+    const value = paths[varName];
+    if (value === void 0) {
+      diagnostics.push({
+        path: `binding.${bindingSoftware}.outputs`,
+        message: `Path variable "${varName}" used in target "${target}" but not defined in config.paths`,
+        severity: "error"
+      });
+      return match;
+    }
+    return value;
+  });
+  return { resolved, diagnostics };
+}
+
+// src/guardrail-generator/generator.ts
+Handlebars2.registerHelper("json", (value) => {
+  return new Handlebars2.SafeString(JSON.stringify(value, null, 2));
+});
+Handlebars2.registerHelper(
+  "expand",
+  (pattern, options) => {
+    if (typeof pattern !== "string") return "";
+    const hash = options.hash;
+    let result = pattern;
+    for (const [key, val] of Object.entries(hash)) {
+      result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), String(val));
+    }
+    return new Handlebars2.SafeString(result);
+  }
+);
+async function generateGuardrails(options) {
+  const { dsl, config, loadedBindings, filterBindings, dryRun } = options;
+  const outputFiles = [];
+  const diagnostics = [];
+  const policyName = config.activeGuardrailPolicy;
+  if (!policyName) {
+    diagnostics.push({
+      path: "config.active_guardrail_policy",
+      message: "No active_guardrail_policy specified in config \u2014 no guardrails will be generated",
+      severity: "warning"
+    });
+    return { outputFiles, diagnostics };
+  }
+  const policy = dsl.guardrail_policies[policyName];
+  if (!policy) {
+    diagnostics.push({
+      path: "config.active_guardrail_policy",
+      message: `Active guardrail policy "${policyName}" not found in DSL guardrail_policies`,
+      severity: "error"
+    });
+    return { outputFiles, diagnostics };
+  }
+  const allBindings = {};
+  for (const lb of loadedBindings) {
+    allBindings[lb.binding.software] = lb.binding;
+  }
+  let reporting = null;
+  for (const lb of loadedBindings) {
+    if (lb.binding.reporting) {
+      reporting = {
+        commands: lb.binding.reporting.commands,
+        fail_open: lb.binding.reporting.fail_open,
+        timeout_ms: lb.binding.reporting.timeout_ms
+      };
+      break;
+    }
+  }
+  const paths = config.paths ?? {};
+  const vars = config.vars ?? {};
+  for (const lb of loadedBindings) {
+    const binding = lb.binding;
+    if (filterBindings && !filterBindings.includes(binding.software)) {
+      continue;
+    }
+    if (!binding.outputs) continue;
+    const checkResult = resolveChecks(dsl, binding, policy);
+    diagnostics.push(...checkResult.diagnostics);
+    const ctx = {
+      system: { id: dsl.system.id, name: dsl.system.name },
+      guardrails: dsl.guardrails,
+      policy,
+      binding,
+      all_bindings: allBindings,
+      vars,
+      paths,
+      reporting,
+      resolved_checks: checkResult.resolved
+    };
+    for (const [outputId, outputDef] of Object.entries(binding.outputs)) {
+      const pathResult = resolveBindingTargetPath(
+        outputDef.target,
+        paths,
+        binding.software
+      );
+      diagnostics.push(...pathResult.diagnostics);
+      if (pathResult.diagnostics.some((d2) => d2.severity === "error")) {
+        continue;
+      }
+      const targetPath = resolve6(config.configDir, pathResult.resolved);
+      let templateContent;
+      if (outputDef.inline_template) {
+        templateContent = outputDef.inline_template;
+      } else if (outputDef.template) {
+        if (outputDef.template.startsWith("builtin:")) {
+          diagnostics.push({
+            path: `binding.${binding.software}.outputs.${outputId}`,
+            message: `Builtin template "${outputDef.template}" is not yet implemented \u2014 skipping`,
+            severity: "info"
+          });
+          continue;
+        }
+        const templatePath = resolve6(config.configDir, outputDef.template);
+        try {
+          templateContent = await readFile5(templatePath, "utf8");
+        } catch {
+          diagnostics.push({
+            path: `binding.${binding.software}.outputs.${outputId}`,
+            message: `Template file not found: ${templatePath}`,
+            severity: "error"
+          });
+          continue;
+        }
+      } else {
+        diagnostics.push({
+          path: `binding.${binding.software}.outputs.${outputId}`,
+          message: "Output has neither template nor inline_template",
+          severity: "error"
+        });
+        continue;
+      }
+      if (outputDef.group_by) {
+        const groupField = outputDef.group_by;
+        const groups = /* @__PURE__ */ new Map();
+        for (const rc of checkResult.resolved) {
+          const key = String(
+            rc.check[groupField] ?? "default"
+          );
+          if (!groups.has(key)) groups.set(key, []);
+          groups.get(key).push(rc);
+        }
+        for (const [groupKey, groupChecks] of groups) {
+          const groupCtx = {
+            ...ctx,
+            resolved_checks: groupChecks,
+            current_group: groupKey
+          };
+          const compiled = Handlebars2.compile(templateContent, { noEscape: true });
+          const output = compiled(groupCtx);
+          const groupTarget = resolve6(targetPath, groupKey);
+          if (!dryRun) {
+            await mkdir2(dirname6(groupTarget), { recursive: true });
+            await writeFile2(groupTarget, output, "utf8");
+            if (outputDef.executable) {
+              await chmod(groupTarget, 493);
+            }
+          }
+          outputFiles.push(groupTarget);
+        }
+      } else {
+        const compiled = Handlebars2.compile(templateContent, { noEscape: true });
+        const output = compiled(ctx);
+        if (!dryRun) {
+          await mkdir2(dirname6(targetPath), { recursive: true });
+          await writeFile2(targetPath, output, "utf8");
+          if (outputDef.executable) {
+            await chmod(targetPath, 493);
+          }
+        }
+        outputFiles.push(targetPath);
+      }
+    }
+  }
+  return { outputFiles, diagnostics };
+}
+
+// src/cli/commands/generate-guardrails.ts
+var generateGuardrailsCommand = new Command6("generate").description("Generate guardrail runtime artifacts from DSL, policies, and bindings").argument("[type]", "Type of artifacts to generate", "guardrails").option("-c, --config <path>", "Path to agent-contracts.config.yaml").option("--binding <name...>", "Filter to specific software binding(s)").option("--dry-run", "Print what would be generated without writing files", false).option("--quiet", "Suppress output on success", false).action(
+  async (type, opts) => {
+    if (type !== "guardrails") {
+      process.stderr.write(`Unknown generate type: ${type}
+`);
+      process.exit(1);
+    }
+    try {
+      const config = await loadConfig(opts.config);
+      if (!config) {
+        process.stderr.write(
+          "Error: agent-contracts.config.yaml not found. Use --config to specify path.\n"
+        );
+        process.exit(1);
+      }
+      const resolved = await resolve4(config.dsl);
+      const data = config.vars ? substituteVars(resolved.data, config.vars) : resolved.data;
+      const schemaResult = validateSchema(data);
+      if (!schemaResult.success) {
+        process.stderr.write(
+          "Schema validation failed. Run 'agent-contracts validate' for details.\n"
+        );
+        process.exit(1);
+      }
+      const loadedBindings = await loadBindings(config.bindings);
+      const result = await generateGuardrails({
+        dsl: schemaResult.data,
+        config,
+        loadedBindings,
+        filterBindings: opts.binding,
+        dryRun: opts.dryRun
+      });
+      const errors = result.diagnostics.filter((d2) => d2.severity === "error");
+      const warnings = result.diagnostics.filter((d2) => d2.severity === "warning");
+      const infos = result.diagnostics.filter((d2) => d2.severity === "info");
+      if (errors.length > 0) {
+        process.stderr.write("Errors:\n");
+        for (const d2 of errors) {
+          process.stderr.write(`  error [${d2.path}] ${d2.message}
+`);
+        }
+      }
+      if (warnings.length > 0 && !opts.quiet) {
+        process.stderr.write("Warnings:\n");
+        for (const d2 of warnings) {
+          process.stderr.write(`  warning [${d2.path}] ${d2.message}
+`);
+        }
+      }
+      if (infos.length > 0 && !opts.quiet) {
+        for (const d2 of infos) {
+          process.stderr.write(`  info [${d2.path}] ${d2.message}
+`);
+        }
+      }
+      if (errors.length > 0) {
+        process.exit(1);
+      }
+      if (!opts.quiet) {
+        const action = opts.dryRun ? "Would generate" : "Generated";
+        process.stdout.write(
+          `${action} ${result.outputFiles.length} file(s):
+`
+        );
+        for (const f2 of result.outputFiles) {
+          process.stdout.write(`  ${f2}
+`);
+        }
+      }
+    } catch (err) {
+      if (err instanceof ConfigLoadError) {
+        process.stderr.write(`Config error: ${err.message}
+`);
+        process.exit(1);
+      }
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${msg}
+`);
+      process.exit(1);
+    }
+  }
+);
+
 // src/cli/cli.ts
-var program = new Command6();
+var program = new Command7();
 program.name("agent-contracts").description("Agent contracts tooling \u2014 validate, lint, render DSL files").version("0.0.2");
 program.addCommand(resolveCommand);
 program.addCommand(validateCommand);
 program.addCommand(lintCommand);
 program.addCommand(renderCommand);
 program.addCommand(checkCommand);
+program.addCommand(generateGuardrailsCommand);
 program.parse();
 /*! Bundled license information: