agent-contracts 0.10.0 → 0.11.0

package/dist/index.js

@@ -158,11 +158,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(resolve6) {
+      resolve6(value);
     });
   }
-  return new (P2 || (P2 = Promise))(function(resolve5, reject) {
+  return new (P2 || (P2 = Promise))(function(resolve6, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -178,7 +178,7 @@ function __awaiter(thisArg, _arguments, P2, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve5(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve6(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -369,14 +369,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(resolve6, reject) {
+        v2 = o3[n3](v2), settle(resolve6, reject, v2.done, v2.value);
       });
     };
   }
-  function settle(resolve5, reject, d2, v2) {
+  function settle(resolve6, reject, d2, v2) {
     Promise.resolve(v2).then(function(v3) {
-      resolve5({ value: v3, done: d2 });
+      resolve6({ value: v3, done: d2 });
     }, reject);
   }
 }
@@ -6292,7 +6292,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 };
@@ -6333,7 +6333,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;
@@ -8022,7 +8022,7 @@ __export(index_es_exports2, {
   resolveExternalRef: () => ye,
   resolveExternalRefWithLocation: () => ge,
   resolveInlineRef: () => B,
-  resolveInlineRefWithLocation: () => z13,
+  resolveInlineRefWithLocation: () => z15,
   safeParse: () => de,
   safeStringify: () => ve,
   startsWith: () => be,
@@ -8066,9 +8066,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 z13(e3, t3).value;
+  return z15(e3, t3).value;
 }
-function z13(e3, t3) {
+function z15(e3, t3) {
   return (function e4(t4, r3, n3, o3) {
     if (null !== V(r3)) throw new ReferenceError("Cannot resolve external references");
     const i3 = K(r3);
@@ -12936,13 +12936,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,
@@ -13032,11 +13032,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(resolve6) {
+      resolve6(value);
     });
   }
-  return new (P2 || (P2 = Promise))(function(resolve5, reject) {
+  return new (P2 || (P2 = Promise))(function(resolve6, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -13052,7 +13052,7 @@ function __awaiter2(thisArg, _arguments, P2, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve5(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve6(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -13230,14 +13230,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(resolve6, reject) {
+        v2 = o3[n3](v2), settle(resolve6, reject, v2.done, v2.value);
       });
     };
   }
-  function settle(resolve5, reject, d2, v2) {
+  function settle(resolve6, reject, d2, v2) {
     Promise.resolve(v2).then(function(v3) {
-      resolve5({ value: v3, done: d2 });
+      resolve6({ value: v3, done: d2 });
     }, reject);
   }
 }
@@ -15151,7 +15151,7 @@ function consumeBody() {
   let accum = [];
   let accumBytes = 0;
   let abort = false;
-  return new Body.Promise(function(resolve5, reject) {
+  return new Body.Promise(function(resolve6, reject) {
     let resTimeout;
     if (_this4.timeout) {
       resTimeout = setTimeout(function() {
@@ -15185,7 +15185,7 @@ function consumeBody() {
       }
       clearTimeout(resTimeout);
       try {
-        resolve5(Buffer.concat(accum, accumBytes));
+        resolve6(Buffer.concat(accum, accumBytes));
       } catch (err) {
         reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, "system", err));
       }
@@ -15448,7 +15448,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(resolve6, reject) {
     const request = new Request(url, opts);
     const options = getNodeRequestOptions(request);
     const send = (options.protocol === "https:" ? https : http).request;
@@ -15581,7 +15581,7 @@ function fetch(url, opts) {
               requestOpts.body = void 0;
               requestOpts.headers.delete("content-length");
             }
-            resolve5(fetch(new Request(locationURL, requestOpts)));
+            resolve6(fetch(new Request(locationURL, requestOpts)));
             finalize();
             return;
         }
@@ -15602,7 +15602,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);
+        resolve6(response);
         return;
       }
       const zlibOptions = {
@@ -15612,7 +15612,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);
+        resolve6(response);
         return;
       }
       if (codings == "deflate" || codings == "x-deflate") {
@@ -15624,12 +15624,12 @@ function fetch(url, opts) {
             body = body.pipe(zlib.createInflateRaw());
           }
           response = new Response(body, response_options);
-          resolve5(response);
+          resolve6(response);
         });
         raw.on("end", function() {
           if (!response) {
             response = new Response(body, response_options);
-            resolve5(response);
+            resolve6(response);
           }
         });
         return;
@@ -15637,11 +15637,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);
+        resolve6(response);
         return;
       }
       response = new Response(body, response_options);
-      resolve5(response);
+      resolve6(response);
     });
     writeToStream(req, request);
   });
@@ -16354,13 +16354,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((resolve6, reject) => {
         const path = ref.href();
         fs_1.readFile(path, "utf8", (err, data) => {
           if (err) {
             reject(err);
           } else {
-            resolve5(data);
+            resolve6(data);
           }
         });
       });
@@ -16898,7 +16898,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;
@@ -17291,7 +17291,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];
@@ -17301,7 +17301,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];
@@ -23932,7 +23932,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;
@@ -23963,12 +23963,12 @@ var require_reader = __commonJS({
         }
       } else {
         try {
-          return await new Promise((resolve5, reject) => {
+          return await new Promise((resolve6, reject) => {
             fs.readFile(name, opts.encoding, (err, data) => {
               if (err !== null) {
                 reject(err);
               } else {
-                resolve5(data);
+                resolve6(data);
               }
             });
           });
@@ -23977,10 +23977,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)}`);
       }
@@ -35640,11 +35640,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;
               }
             }
           }
@@ -40853,14 +40853,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(resolve6) {
         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));
+        resolve6($then(valueWrapper, onFulfilled));
       });
     };
   }
@@ -41408,7 +41408,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(resolve6) {
           var syncIteratorRecord = SLOT.get(O2, "[[SyncIteratorRecord]]");
           var result;
           if (argsLength > 0) {
@@ -41416,7 +41416,7 @@ var require_CreateAsyncFromSyncIterator = __commonJS({
           } else {
             result = IteratorNext(syncIteratorRecord);
           }
-          resolve5(AsyncFromSyncIteratorContinuation(result));
+          resolve6(AsyncFromSyncIteratorContinuation(result));
         });
       },
       "return": function() {
@@ -41427,12 +41427,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(resolve6, 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(resolve6, void 0, [iterResult]);
             return;
           }
           var result;
@@ -41445,7 +41445,7 @@ var require_CreateAsyncFromSyncIterator = __commonJS({
             Call(reject, void 0, [new $TypeError("Iterator `return` method returned a non-object value.")]);
             return;
           }
-          resolve5(AsyncFromSyncIteratorContinuation(result));
+          resolve6(AsyncFromSyncIteratorContinuation(result));
         });
       },
       "throw": function() {
@@ -41456,7 +41456,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(resolve6, reject) {
           var syncIterator = SLOT.get(O2, "[[SyncIteratorRecord]]")["[[Iterator]]"];
           var throwMethod = GetMethod(syncIterator, "throw");
           if (typeof throwMethod === "undefined") {
@@ -41473,7 +41473,7 @@ var require_CreateAsyncFromSyncIterator = __commonJS({
             Call(reject, void 0, [new $TypeError("Iterator `throw` method returned a non-object value.")]);
             return;
           }
-          resolve5(AsyncFromSyncIteratorContinuation(
+          resolve6(AsyncFromSyncIteratorContinuation(
             result
             /* , promiseCapability */
           ));
@@ -49168,7 +49168,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("/");
@@ -50480,184 +50480,273 @@ var ArtifactSchema = z2.object({
   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 z10 } from "zod";
+import { z as z12 } from "zod";
 
 // src/schema/handoff-type.ts
-import { z as z3 } from "zod";
-var HandoffTypeSchema = z3.object({
-  version: z3.number(),
-  description: z3.string().optional(),
-  schema: z3.record(z3.string(), z3.any()),
-  example: z3.record(z3.string(), z3.any()).optional()
+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 z4 } from "zod";
-var PolicyWhenSchema = z4.object({
-  artifact_type: z4.string().optional(),
-  workflow: z4.string().optional()
+import { z as z6 } from "zod";
+var PolicyWhenSchema = z6.object({
+  artifact_type: z6.string().optional(),
+  workflow: z6.string().optional()
 }).passthrough();
-var PolicySchema = z4.object({
+var PolicySchema = z6.object({
   when: PolicyWhenSchema,
-  requires_validations: z4.array(z4.string()).optional(),
-  requires: z4.array(z4.string()).optional()
+  requires_validations: z6.array(z6.string()).optional(),
+  requires: z6.array(z6.string()).optional()
 }).passthrough();
 
 // src/schema/system.ts
-import { z as z5 } from "zod";
-var VersionLiteralSchema = z5.literal(1);
-var ExtendsSchema = z5.string().optional();
-var SystemSchema = z5.object({
-  id: z5.string(),
-  name: z5.string(),
-  default_workflow_order: z5.array(z5.string())
+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 z6 } from "zod";
-var ExecutionStepSchema = z6.object({
-  id: z6.string(),
-  action: z6.string(),
-  description: z6.string().optional(),
-  required: z6.boolean().optional(),
-  abort_on_failure: z6.boolean().optional(),
-  uses_tool: z6.string().optional(),
-  produces_artifact: z6.string().optional(),
-  reads_artifact: z6.string().optional(),
-  depends_on: z6.array(z6.string()).optional(),
-  skip_condition: z6.string().optional(),
-  wait_for_approval: z6.boolean().optional()
+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 = z6.object({
-  description: z6.string(),
-  target_agent: z6.string(),
-  allowed_from_agents: z6.array(z6.string()),
-  workflow: z6.string(),
-  input_artifacts: z6.array(z6.string()),
-  invocation_handoff: z6.string(),
-  result_handoff: z6.string(),
-  default_priority: z6.string().optional(),
-  responsibilities: z6.array(z6.string()).optional(),
-  constraints: z6.array(z6.string()).optional(),
-  execution_steps: z6.array(ExecutionStepSchema).optional(),
-  completion_criteria: z6.array(z6.string()).optional(),
-  rules: z6.array(RuleSchema).optional(),
-  anti_patterns: z6.array(z6.string()).optional(),
-  escalation_criteria: z6.array(EscalationCriterionSchema).optional(),
-  validations: z6.array(z6.string()).default([])
+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 z7 } from "zod";
-var CommandSchema = z7.object({
-  command: z7.string(),
-  category: z7.string(),
-  reads: z7.array(z7.string()).default([]),
-  writes: z7.array(z7.string()).default([]),
-  purpose: z7.string().optional()
-});
-var ToolSchema = z7.object({
-  kind: z7.string(),
-  description: z7.string().optional(),
-  input_artifacts: z7.array(z7.string()).default([]),
-  output_artifacts: z7.array(z7.string()).default([]),
-  invokable_by: z7.array(z7.string()),
-  side_effects: z7.array(z7.string()).default([]),
-  commands: z7.array(CommandSchema).default([])
+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 z8 } from "zod";
-var ValidationSchema = z8.object({
-  target_artifact: z8.string(),
-  kind: z8.enum(["schema", "mechanical", "semantic", "approval"]),
-  executor_type: z8.enum(["tool", "agent"]),
-  executor: z8.string(),
-  blocking: z8.boolean(),
-  produces_evidence: z8.string().optional()
+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 z9 } from "zod";
-var RetrySchema = z9.object({
-  condition: z9.string(),
-  fix_task: z9.string(),
-  revalidate_task: z9.string().optional()
-});
-var ExternalParticipantSchema = z9.object({
-  id: z9.string(),
-  kind: z9.enum(["actor", "participant"]),
-  label: z9.string(),
-  description: z9.string().optional()
-});
-var WorkflowDelegateStepSchema = z9.object({
-  type: z9.literal("delegate"),
-  description: z9.string().optional(),
-  task: z9.string(),
-  from_agent: z9.string(),
-  group: z9.string().optional(),
+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 = z9.object({
-  type: z9.literal("gate"),
-  description: z9.string().optional(),
-  gate_kind: z9.string(),
-  group: z9.string().optional()
+var WorkflowGateStepSchema = z11.object({
+  type: z11.literal("gate"),
+  description: z11.string().optional(),
+  gate_kind: z11.string(),
+  group: z11.string().optional()
 }).passthrough();
-var WorkflowHandoffStepSchema = z9.object({
-  type: z9.literal("handoff"),
-  description: z9.string().optional(),
-  handoff_kind: z9.string(),
-  task: z9.string().optional(),
-  from_agent: z9.string().optional(),
-  group: z9.string().optional(),
+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 = z9.object({
-  type: z9.literal("validation"),
-  description: z9.string().optional(),
-  validation: z9.string(),
-  group: z9.string().optional()
+var WorkflowValidationStepSchema = z11.object({
+  type: z11.literal("validation"),
+  description: z11.string().optional(),
+  validation: z11.string(),
+  group: z11.string().optional()
 }).passthrough();
-var WorkflowDecisionStepSchema = z9.object({
-  type: z9.literal("decision"),
-  description: z9.string().optional(),
-  on: z9.string(),
-  branches: z9.record(z9.string(), z9.array(z9.string())),
-  group: z9.string().optional()
+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 = z9.discriminatedUnion("type", [
+var WorkflowStepSchema = z11.discriminatedUnion("type", [
   WorkflowDelegateStepSchema,
   WorkflowGateStepSchema,
   WorkflowHandoffStepSchema,
   WorkflowValidationStepSchema,
   WorkflowDecisionStepSchema
 ]);
-var WorkflowSchema = z9.object({
-  description: z9.string().optional(),
-  entry_conditions: z9.array(z9.string()).default([]),
-  trigger: z9.string().optional(),
-  steps: z9.array(WorkflowStepSchema),
-  external_participants: z9.array(ExternalParticipantSchema).default([])
+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 = z10.object({
-  schemas: z10.record(z10.string(), z10.record(z10.string(), z10.any())).default({})
+var ComponentsSchema = z12.object({
+  schemas: z12.record(z12.string(), z12.record(z12.string(), z12.any())).default({})
 }).passthrough();
-var DslSchema = z10.object({
-  version: z10.literal(1),
-  extends: z10.string().optional(),
+var DslSchema = z12.object({
+  version: z12.literal(1),
+  extends: z12.string().optional(),
   system: SystemSchema,
-  agents: z10.record(z10.string(), AgentSchema).default({}),
-  tasks: z10.record(z10.string(), TaskSchema).default({}),
-  artifacts: z10.record(z10.string(), ArtifactSchema).default({}),
-  tools: z10.record(z10.string(), ToolSchema).default({}),
-  validations: z10.record(z10.string(), ValidationSchema).default({}),
-  handoff_types: z10.record(z10.string(), HandoffTypeSchema).default({}),
-  workflow: z10.record(z10.string(), WorkflowSchema).default({}),
-  policies: z10.record(z10.string(), PolicySchema).default({}),
+  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();
 
@@ -50710,22 +50799,22 @@ function resolveAllOf(schema) {
 }
 
 // src/schema/merge-operators.ts
-import { z as z11 } from "zod";
-var AppendOperatorSchema = z11.object({
-  $append: z11.record(z11.string(), z11.any())
+import { z as z13 } from "zod";
+var AppendOperatorSchema = z13.object({
+  $append: z13.record(z13.string(), z13.any())
 });
-var PrependOperatorSchema = z11.object({
-  $prepend: z11.record(z11.string(), z11.any())
+var PrependOperatorSchema = z13.object({
+  $prepend: z13.record(z13.string(), z13.any())
 });
-var InsertAfterOperatorSchema = z11.object({
-  $insert_after: z11.object({
-    after: z11.string(),
-    entries: z11.record(z11.string(), z11.any())
+var InsertAfterOperatorSchema = z13.object({
+  $insert_after: z13.object({
+    after: z13.string(),
+    entries: z13.record(z13.string(), z13.any())
   })
 });
-var ReplaceOperatorSchema = z11.object({ $replace: z11.any() });
-var RemoveOperatorSchema = z11.object({
-  $remove: z11.array(z11.string())
+var ReplaceOperatorSchema = z13.object({ $replace: z13.any() });
+var RemoveOperatorSchema = z13.object({
+  $remove: z13.array(z13.string())
 });
 
 // src/loader/loader.ts
@@ -51275,6 +51364,8 @@ var MERGE_SECTIONS = [
   "handoff_types",
   "workflow",
   "policies",
+  "guardrails",
+  "guardrail_policies",
   "components"
 ];
 function mergeDsl(base, project) {
@@ -51330,16 +51421,16 @@ async function resolve3(projectDirOrFile) {
 }
 
 // src/validator/schema-validator.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 function unwrap(schema) {
-  if (schema instanceof z12.ZodOptional) return unwrap(schema.unwrap());
-  if (schema instanceof z12.ZodDefault) return unwrap(schema.removeDefault());
-  if (schema instanceof z12.ZodNullable) return unwrap(schema.unwrap());
+  if (schema instanceof z14.ZodOptional) return unwrap(schema.unwrap());
+  if (schema instanceof z14.ZodDefault) return unwrap(schema.removeDefault());
+  if (schema instanceof z14.ZodNullable) return unwrap(schema.unwrap());
   return schema;
 }
 function checkCustomPropsRecursive(data, schema, path) {
   const inner = unwrap(schema);
-  if (inner instanceof z12.ZodObject) {
+  if (inner instanceof z14.ZodObject) {
     if (typeof data !== "object" || data === null || Array.isArray(data)) return [];
     const obj = data;
     const shape = inner.shape;
@@ -51360,7 +51451,7 @@ function checkCustomPropsRecursive(data, schema, path) {
     }
     return diagnostics;
   }
-  if (inner instanceof z12.ZodRecord) {
+  if (inner instanceof z14.ZodRecord) {
     if (typeof data !== "object" || data === null || Array.isArray(data)) return [];
     const valueSchema = inner._def.valueType;
     const diagnostics = [];
@@ -51369,7 +51460,7 @@ function checkCustomPropsRecursive(data, schema, path) {
     }
     return diagnostics;
   }
-  if (inner instanceof z12.ZodArray) {
+  if (inner instanceof z14.ZodArray) {
     if (!Array.isArray(data)) return [];
     const diagnostics = [];
     for (let i3 = 0; i3 < data.length; i3++) {
@@ -51377,14 +51468,14 @@ function checkCustomPropsRecursive(data, schema, path) {
     }
     return diagnostics;
   }
-  if (inner instanceof z12.ZodDiscriminatedUnion) {
+  if (inner instanceof z14.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 z12.ZodLiteral && shape[disc].value === discValue;
+      return shape[disc] instanceof z14.ZodLiteral && shape[disc].value === discValue;
     });
     if (match) return checkCustomPropsRecursive(data, match, path);
     return [];
@@ -51418,12 +51509,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
       });
     }
   }
@@ -51611,6 +51703,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;
 }
 
@@ -51985,6 +52146,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,
@@ -51992,7 +52179,8 @@ var builtinRules = [
   taskAgentBindingRule,
   mergeIntegrityRule,
   artifactOwnershipRule,
-  toolCommandsRule
+  toolCommandsRule,
+  guardrailPolicyCoverageRule
 ];
 function lint(dsl, rules = builtinRules) {
   const diagnostics = [];
@@ -52654,7 +52842,9 @@ function buildGlobalContext(dsl) {
     validations: dsl.validations,
     handoff_types: dsl.handoff_types,
     workflow: dsl.workflow,
-    policies: dsl.policies
+    policies: dsl.policies,
+    guardrails: dsl.guardrails,
+    guardrail_policies: dsl.guardrail_policies
   };
 }
 function buildSystemContext(dsl) {
@@ -52865,6 +53055,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"]));
@@ -53712,7 +53912,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] ?? {};
 }
@@ -53745,6 +53947,10 @@ 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);
   }
@@ -53813,8 +54019,17 @@ async function checkDriftFromConfig(dsl, renderTargets) {
   return { hasDrift: diffs.length > 0, diffs };
 }
 
+// src/config/binding-loader.ts
+import { readFile as readFile4 } from "fs/promises";
+import { parse as parseYaml3 } from "yaml";
+
+// src/config/loader.ts
+import { readFile as readFile3, access } from "fs/promises";
+import { resolve as resolve4, dirname as dirname4 } from "path";
+import { parse as parseYaml2 } from "yaml";
+
 // src/config/types.ts
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 var CONTEXT_TYPES = [
   "agent",
   "task",
@@ -53824,18 +54039,20 @@ var CONTEXT_TYPES = [
   "handoff_type",
   "workflow",
   "policy",
+  "guardrail",
+  "guardrail_policy",
   "system"
 ];
-var ContextTypeSchema = z14.enum(CONTEXT_TYPES);
+var ContextTypeSchema = z16.enum(CONTEXT_TYPES);
 var ITERABLE_CONTEXT_TYPES = CONTEXT_TYPES.filter(
   (t3) => t3 !== "system"
 );
-var RenderTargetSchema = z14.object({
-  template: z14.string(),
+var RenderTargetSchema = z16.object({
+  template: z16.string(),
   context: ContextTypeSchema,
-  output: z14.string(),
-  include: z14.array(z14.string()).optional(),
-  exclude: z14.array(z14.string()).optional()
+  output: z16.string(),
+  include: z16.array(z16.string()).optional(),
+  exclude: z16.array(z16.string()).optional()
 }).refine(
   (data) => !(data.include && data.exclude),
   { message: "include and exclude are mutually exclusive" }
@@ -53848,16 +54065,16 @@ var RenderTargetSchema = z14.object({
   },
   { message: "include/exclude cannot be used with context: system" }
 );
-var AgentContractsConfigSchema = z14.object({
-  dsl: z14.string(),
-  vars: z14.record(z14.string(), z14.string()).optional(),
-  renders: z14.array(RenderTargetSchema).min(1)
+var AgentContractsConfigSchema = z16.object({
+  dsl: z16.string(),
+  vars: z16.record(z16.string(), z16.string()).optional(),
+  renders: z16.array(RenderTargetSchema).min(1),
+  bindings: z16.array(z16.string()).default([]),
+  active_guardrail_policy: z16.string().optional(),
+  paths: z16.record(z16.string(), z16.string()).optional()
 });
 
 // src/config/loader.ts
-import { readFile as readFile3, access } from "fs/promises";
-import { resolve as resolve4, dirname as dirname4 } from "path";
-import { parse as parseYaml2 } from "yaml";
 var DEFAULT_CONFIG_NAME = "agent-contracts.config.yaml";
 var ConfigLoadError = class extends Error {
   constructor(message, filePath) {
@@ -53925,7 +54142,10 @@ ${issues}`,
       template: resolve4(configDir, r3.template),
       output: resolve4(configDir, r3.output)
     })),
-    configDir
+    configDir,
+    bindings: (config.bindings ?? []).map((b3) => resolve4(configDir, b3)),
+    activeGuardrailPolicy: config.active_guardrail_policy,
+    paths: config.paths
   };
 }
 function resolveDslPath(dirArg, dirArgDefault, config) {
@@ -53937,13 +54157,272 @@ function resolveDslPath(dirArg, dirArgDefault, config) {
   }
   return resolve4(dirArgDefault);
 }
+
+// src/config/binding-loader.ts
+async function loadBindings(bindingPaths) {
+  const results = [];
+  for (const filePath of bindingPaths) {
+    let content;
+    try {
+      content = await readFile4(filePath, "utf8");
+    } catch {
+      throw new ConfigLoadError(
+        `Failed to read binding file: ${filePath}`,
+        filePath
+      );
+    }
+    let raw;
+    try {
+      raw = 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
+      );
+    }
+    const result = SoftwareBindingSchema.safeParse(raw);
+    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/guardrail-generator/generator.ts
+import { readFile as readFile5, writeFile as writeFile2, mkdir as mkdir2, chmod } from "fs/promises";
+import { resolve as resolve5, dirname as dirname5 } 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 = resolve5(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 = resolve5(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 = resolve5(targetPath, groupKey);
+          if (!dryRun) {
+            await mkdir2(dirname5(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(dirname5(targetPath), { recursive: true });
+          await writeFile2(targetPath, output, "utf8");
+          if (outputDef.executable) {
+            await chmod(targetPath, 493);
+          }
+        }
+        outputFiles.push(targetPath);
+      }
+    }
+  }
+  return { outputFiles, diagnostics };
+}
 export {
   AgentContractsConfigSchema,
   AgentSchema,
   AppendOperatorSchema,
   ArtifactSchema,
   BaseResolveError,
+  BindingOutputSchema,
   CONTEXT_TYPES,
+  CheckSchema,
   CommandSchema,
   ComponentsSchema,
   ConfigLoadError,
@@ -53953,8 +54432,14 @@ export {
   EscalationCriterionSchema,
   ExecutionStepSchema,
   ExtendsSchema,
+  GuardrailPolicyRuleEscalationSchema,
+  GuardrailPolicyRuleSchema,
+  GuardrailPolicySchema,
+  GuardrailSchema,
+  GuardrailScopeSchema,
   HandoffTypeSchema,
   InsertAfterOperatorSchema,
+  MatcherSchema,
   MergeError,
   PolicySchema,
   PolicyWhenSchema,
@@ -53963,7 +54448,9 @@ export {
   RemoveOperatorSchema,
   RenderTargetSchema,
   ReplaceOperatorSchema,
+  ReportingSchema,
   RuleSchema,
+  SoftwareBindingSchema,
   SystemSchema,
   TaskSchema,
   ToolSchema,
@@ -53973,6 +54460,8 @@ export {
   WorkflowStepSchema,
   buildArtifactContext,
   buildGlobalContext,
+  buildGuardrailContext,
+  buildGuardrailPolicyContext,
   buildHandoffTypeContext,
   buildPerAgentContext,
   buildPolicyContext,
@@ -53984,7 +54473,9 @@ export {
   builtinRules,
   checkDriftFromConfig,
   checkReferences,
+  generateGuardrails,
   lint,
+  loadBindings,
   loadConfig,
   loadDsl,
   mergeDsl,
@@ -53992,6 +54483,8 @@ export {
   resolve3 as resolve,
   resolveAllOf,
   resolveBase,
+  resolveBindingTargetPath,
+  resolveChecks,
   resolveDslPath,
   spectralLint,
   validateHandoffSchemas,