agent-contracts 0.13.0 → 0.14.0

package/dist/index.js

@@ -6292,7 +6292,7 @@ var init_index_es = __esm({
         return { drive: t4.toLowerCase() + ":" };
       }, k2 = function() {
         return { drive: null };
-      }, z17 = function() {
+      }, z18 = 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 = z17()), t5;
+            return (t5 = x3) !== c2 && (t5 = z18()), 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: () => z15,
+  resolveInlineRefWithLocation: () => z16,
   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 z15(e3, t3).value;
+  return z16(e3, t3).value;
 }
-function z15(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);
@@ -16898,7 +16898,7 @@ var require_immer_cjs_production_min = __commonJS({
       var t4 = n4[H2];
       return (t4 ? s2(t4) : n4)[r4];
     }
-    function z17(n4, r4) {
+    function z18(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 = z17(r5, t4);
+        var e5, i5 = z18(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 = z17(s2(n4), r4);
+      var e4 = z18(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];
@@ -35640,11 +35640,11 @@ var require_brace_expansion = __commonJS({
             if (pad) {
               var need = width - c2.length;
               if (need > 0) {
-                var z17 = new Array(need + 1).join("0");
+                var z18 = new Array(need + 1).join("0");
                 if (i3 < 0)
-                  c2 = "-" + z17 + c2.slice(1);
+                  c2 = "-" + z18 + c2.slice(1);
                 else
-                  c2 = z17 + c2;
+                  c2 = z18 + c2;
               }
             }
           }
@@ -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, z17) => zs.concat(z17), xs)
+      (xs) => (ys) => ys.reduce((zs, z18) => zs.concat(z18), xs)
     );
     function getLastSegment(instancePath) {
       const index4 = instancePath.lastIndexOf("/");
@@ -50483,44 +50483,66 @@ var ArtifactSchema = z2.object({
 }).passthrough();
 
 // src/schema/binding.ts
+import { z as z4 } from "zod";
+
+// src/schema/context-type.ts
 import { z as z3 } from "zod";
-var CommandRegexMatcherSchema = z3.object({
-  type: z3.literal("command_regex"),
-  pattern: z3.string()
+var CONTEXT_TYPES = [
+  "agent",
+  "task",
+  "artifact",
+  "tool",
+  "validation",
+  "handoff_type",
+  "workflow",
+  "policy",
+  "guardrail",
+  "guardrail_policy",
+  "system"
+];
+var ContextTypeSchema = z3.enum(CONTEXT_TYPES);
+var ITERABLE_CONTEXT_TYPES = CONTEXT_TYPES.filter(
+  (t3) => t3 !== "system"
+);
+
+// src/schema/binding.ts
+var CommandRegexMatcherSchema = z4.object({
+  type: z4.literal("command_regex"),
+  pattern: z4.string()
 }).passthrough();
-var ContentRegexMatcherSchema = z3.object({
-  type: z3.literal("content_regex"),
-  pattern: z3.string(),
-  file_glob: z3.string().optional(),
-  exclude_glob: z3.string().optional()
+var ContentRegexMatcherSchema = z4.object({
+  type: z4.literal("content_regex"),
+  pattern: z4.string(),
+  file_glob: z4.string().optional(),
+  exclude_glob: z4.string().optional()
 }).passthrough();
-var FileGlobMatcherSchema = z3.object({
-  type: z3.literal("file_glob"),
-  pattern: z3.string(),
-  exclude_glob: z3.string().optional()
+var FileGlobMatcherSchema = z4.object({
+  type: z4.literal("file_glob"),
+  pattern: z4.string(),
+  exclude_glob: z4.string().optional()
 }).passthrough();
-var MatcherSchema = z3.discriminatedUnion("type", [
+var MatcherSchema = z4.discriminatedUnion("type", [
   CommandRegexMatcherSchema,
   ContentRegexMatcherSchema,
   FileGlobMatcherSchema
 ]);
-var CheckSchema = z3.object({
+var CheckSchema = z4.object({
   matcher: MatcherSchema.optional(),
-  script: z3.string().optional(),
-  message: z3.string().optional()
+  script: z4.string().optional(),
+  message: z4.string().optional()
 }).passthrough();
-var BindingOutputSchema = z3.object({
-  target: z3.string(),
-  template: z3.string().optional(),
-  inline_template: z3.string().optional(),
-  source: z3.string().optional(),
-  mode: z3.enum(["write", "patch"]).default("write"),
-  format: z3.enum(["json", "yaml", "text"]).optional(),
-  patch_strategy: z3.enum(["deep_merge", "append"]).optional(),
-  array_merge_key: z3.string().optional(),
-  group_by: z3.string().optional(),
-  executable: z3.boolean().optional(),
-  skip_empty: z3.boolean().optional()
+var BindingOutputSchema = z4.object({
+  target: z4.string(),
+  template: z4.string().optional(),
+  inline_template: z4.string().optional(),
+  source: z4.string().optional(),
+  mode: z4.enum(["write", "patch"]).default("write"),
+  format: z4.enum(["json", "yaml", "text"]).optional(),
+  patch_strategy: z4.enum(["deep_merge", "append"]).optional(),
+  array_merge_key: z4.string().optional(),
+  group_by: z4.string().optional(),
+  executable: z4.boolean().optional(),
+  skip_empty: z4.boolean().optional()
 }).passthrough().refine(
   (data) => {
     const count = [data.template, data.inline_template, data.source].filter(Boolean).length;
@@ -50528,225 +50550,253 @@ var BindingOutputSchema = z3.object({
   },
   { message: "Only one of template, inline_template, or source may be specified" }
 );
-var ReportingSchema = z3.object({
-  commands: z3.record(z3.string(), z3.string()),
-  fail_open: z3.boolean().default(true),
-  timeout_ms: z3.number().default(5e3)
+var ReportingSchema = z4.object({
+  commands: z4.record(z4.string(), z4.string()),
+  fail_open: z4.boolean().default(true),
+  timeout_ms: z4.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(),
+var GuardrailImplSchema = z4.object({
+  checks: z4.array(CheckSchema)
+});
+var BindingRenderTargetSchema = z4.object({
+  template: z4.string().optional(),
+  inline_template: z4.string().optional(),
+  context: ContextTypeSchema,
+  output: z4.string(),
+  include: z4.array(z4.string()).optional(),
+  exclude: z4.array(z4.string()).optional(),
+  skip_empty: z4.boolean().optional(),
+  executable: z4.boolean().optional()
+}).passthrough().refine(
+  (data) => {
+    const count = [data.template, data.inline_template].filter(Boolean).length;
+    return count === 1;
+  },
+  { message: "Exactly one of template or inline_template must be specified" }
+).refine(
+  (data) => !(data.include && data.exclude),
+  { message: "include and exclude are mutually exclusive" }
+).refine(
+  (data) => {
+    if (data.context === "system" && (data.include || data.exclude)) {
+      return false;
+    }
+    return true;
+  },
+  { message: "include/exclude cannot be used with context: system" }
+);
+var SoftwareBindingSchema = z4.object({
+  software: z4.string(),
+  version: z4.literal(1),
+  extends: z4.string().optional(),
+  guardrail_impl: z4.record(z4.string(), GuardrailImplSchema).optional(),
+  outputs: z4.record(z4.string(), BindingOutputSchema).optional(),
+  renders: z4.array(BindingRenderTargetSchema).optional(),
   reporting: ReportingSchema.optional()
 }).passthrough();
 
 // src/schema/dsl.ts
-import { z as z12 } from "zod";
+import { z as z13 } 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()
+import { z as z5 } from "zod";
+var HandoffTypeSchema = z5.object({
+  version: z5.number(),
+  description: z5.string().optional(),
+  schema: z5.record(z5.string(), z5.any()),
+  example: z5.record(z5.string(), z5.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()
+import { z as z6 } from "zod";
+var GuardrailScopeSchema = z6.object({
+  agents: z6.array(z6.string()).optional(),
+  tasks: z6.array(z6.string()).optional(),
+  tools: z6.array(z6.string()).optional(),
+  artifacts: z6.array(z6.string()).optional(),
+  workflows: z6.array(z6.string()).optional()
 }).passthrough();
-var GuardrailSchema = z5.object({
-  description: z5.string(),
+var GuardrailSchema = z6.object({
+  description: z6.string(),
   scope: GuardrailScopeSchema,
-  rationale: z5.string().optional(),
-  tags: z5.array(z5.string()).default([]),
-  exemptions: z5.array(z5.string()).optional()
+  rationale: z6.string().optional(),
+  tags: z6.array(z6.string()).default([]),
+  exemptions: z6.array(z6.string()).optional()
 }).passthrough();
-var GuardrailPolicyRuleEscalationSchema = z5.object({
-  target: z5.string(),
-  condition: z5.string().optional()
+var GuardrailPolicyRuleEscalationSchema = z6.object({
+  target: z6.string(),
+  condition: z6.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(),
+var GuardrailPolicyRuleSchema = z6.object({
+  guardrail: z6.string(),
+  severity: z6.enum(["critical", "mandatory", "warning", "info"]),
+  action: z6.enum(["block", "warn", "shadow", "info"]),
+  allow_override: z6.boolean().default(false),
+  override_requires: z6.array(z6.string()).optional(),
   escalation: GuardrailPolicyRuleEscalationSchema.optional()
 }).passthrough();
-var GuardrailPolicySchema = z5.object({
-  description: z5.string().optional(),
-  rules: z5.array(GuardrailPolicyRuleSchema)
+var GuardrailPolicySchema = z6.object({
+  description: z6.string().optional(),
+  rules: z6.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()
+import { z as z7 } from "zod";
+var PolicyWhenSchema = z7.object({
+  artifact_type: z7.string().optional(),
+  workflow: z7.string().optional()
 }).passthrough();
-var PolicySchema = z6.object({
+var PolicySchema = z7.object({
   when: PolicyWhenSchema,
-  requires_validations: z6.array(z6.string()).optional(),
-  requires: z6.array(z6.string()).optional()
+  requires_validations: z7.array(z7.string()).optional(),
+  requires: z7.array(z7.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({
+var VersionLiteralSchema = z8.literal(1);
+var ExtendsSchema = z8.string().optional();
+var SystemSchema = 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([]),
-  guardrails: z8.array(z8.string()).optional()
+  name: z8.string(),
+  default_workflow_order: z8.array(z8.string())
 }).passthrough();
 
-// src/schema/tool.ts
+// src/schema/task.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(),
+var ExecutionStepSchema = z9.object({
+  id: z9.string(),
+  action: 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([]),
+  required: z9.boolean().optional(),
+  abort_on_failure: z9.boolean().optional(),
+  uses_tool: z9.string().optional(),
+  produces_artifact: z9.string().optional(),
+  reads_artifact: z9.string().optional(),
+  depends_on: z9.array(z9.string()).optional(),
+  skip_condition: z9.string().optional(),
+  wait_for_approval: z9.boolean().optional()
+}).passthrough();
+var TaskSchema = z9.object({
+  description: z9.string(),
+  target_agent: z9.string(),
+  allowed_from_agents: z9.array(z9.string()),
+  workflow: z9.string(),
+  input_artifacts: z9.array(z9.string()),
+  invocation_handoff: z9.string(),
+  result_handoff: z9.string(),
+  default_priority: z9.string().optional(),
+  responsibilities: z9.array(z9.string()).optional(),
+  constraints: z9.array(z9.string()).optional(),
+  execution_steps: z9.array(ExecutionStepSchema).optional(),
+  completion_criteria: z9.array(z9.string()).optional(),
+  rules: z9.array(RuleSchema).optional(),
+  anti_patterns: z9.array(z9.string()).optional(),
+  escalation_criteria: z9.array(EscalationCriterionSchema).optional(),
+  validations: z9.array(z9.string()).default([]),
   guardrails: z9.array(z9.string()).optional()
 }).passthrough();
 
-// src/schema/validation.ts
+// src/schema/tool.ts
 import { z as z10 } from "zod";
-var ValidationSchema = z10.object({
-  target_artifact: z10.string(),
-  kind: z10.enum(["schema", "mechanical", "semantic", "approval", "provenance", "traceability", "fidelity"]),
-  executor_type: z10.enum(["tool", "agent"]),
-  executor: z10.string(),
-  blocking: z10.boolean(),
-  produces_evidence: z10.string().optional()
+var CommandSchema = z10.object({
+  command: z10.string(),
+  category: z10.string(),
+  reads: z10.array(z10.string()).default([]),
+  writes: z10.array(z10.string()).default([]),
+  purpose: z10.string().optional()
+});
+var ToolSchema = z10.object({
+  kind: z10.string(),
+  description: z10.string().optional(),
+  input_artifacts: z10.array(z10.string()).default([]),
+  output_artifacts: z10.array(z10.string()).default([]),
+  invokable_by: z10.array(z10.string()),
+  side_effects: z10.array(z10.string()).default([]),
+  commands: z10.array(CommandSchema).default([]),
+  guardrails: z10.array(z10.string()).optional()
 }).passthrough();
 
-// src/schema/workflow.ts
+// src/schema/validation.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(),
+var ValidationSchema = z11.object({
+  target_artifact: z11.string(),
+  kind: z11.enum(["schema", "mechanical", "semantic", "approval", "provenance", "traceability", "fidelity"]),
+  executor_type: z11.enum(["tool", "agent"]),
+  executor: z11.string(),
+  blocking: z11.boolean(),
+  produces_evidence: z11.string().optional()
+}).passthrough();
+
+// src/schema/workflow.ts
+import { z as z12 } from "zod";
+var RetrySchema = z12.object({
+  condition: z12.string(),
+  fix_task: z12.string(),
+  revalidate_task: z12.string().optional()
+});
+var ExternalParticipantSchema = z12.object({
+  id: z12.string(),
+  kind: z12.enum(["actor", "participant"]),
+  label: z12.string(),
+  description: z12.string().optional()
+});
+var WorkflowDelegateStepSchema = z12.object({
+  type: z12.literal("delegate"),
+  description: z12.string().optional(),
+  task: z12.string(),
+  from_agent: z12.string(),
+  group: z12.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()
+var WorkflowGateStepSchema = z12.object({
+  type: z12.literal("gate"),
+  description: z12.string().optional(),
+  gate_kind: z12.string(),
+  group: z12.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(),
+var WorkflowHandoffStepSchema = z12.object({
+  type: z12.literal("handoff"),
+  description: z12.string().optional(),
+  handoff_kind: z12.string(),
+  task: z12.string().optional(),
+  from_agent: z12.string().optional(),
+  group: z12.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()
+var WorkflowValidationStepSchema = z12.object({
+  type: z12.literal("validation"),
+  description: z12.string().optional(),
+  validation: z12.string(),
+  group: z12.string().optional()
 }).passthrough();
-var WorkflowDecisionStepSchema = z11.object({
-  type: z11.literal("decision"),
-  description: z11.string().optional(),
+var WorkflowDecisionStepSchema = z12.object({
+  type: z12.literal("decision"),
+  description: z12.string().optional(),
   /** @deprecated Use `routing_key` instead. `on` is kept for backward compatibility. */
-  on: z11.string().optional(),
-  routing_key: z11.string().optional(),
-  branches: z11.record(z11.string(), z11.array(z11.string())),
-  group: z11.string().optional()
+  on: z12.string().optional(),
+  routing_key: z12.string().optional(),
+  branches: z12.record(z12.string(), z12.array(z12.string())),
+  group: z12.string().optional()
 }).passthrough();
-var WorkflowStepSchema = z11.discriminatedUnion("type", [
+var WorkflowStepSchema = z12.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([])
+var WorkflowSchema = z12.object({
+  description: z12.string().optional(),
+  entry_conditions: z12.array(z12.string()).default([]),
+  trigger: z12.string().optional(),
+  steps: z12.array(WorkflowStepSchema),
+  external_participants: z12.array(ExternalParticipantSchema).default([])
 }).passthrough();
 
 // src/schema/dsl.ts
-var ComponentsSchema = z12.object({
-  schemas: z12.record(z12.string(), z12.record(z12.string(), z12.any())).default({})
+var ComponentsSchema = z13.object({
+  schemas: z13.record(z13.string(), z13.record(z13.string(), z13.any())).default({})
 }).passthrough();
 var SCOPE_NODE_TYPES = [
   "root",
@@ -50768,32 +50818,32 @@ var SCOPE_NODE_TYPES = [
   "escalation_criterion",
   "prerequisite"
 ];
-var ScopeNodeTypeSchema = z12.enum(SCOPE_NODE_TYPES);
-var XExtensionDeclSchema = z12.object({
-  type: z12.string(),
-  items: z12.string().optional(),
-  description: z12.string().optional(),
-  scope: z12.array(ScopeNodeTypeSchema).optional(),
-  schema: z12.record(z12.string(), z12.any()).optional(),
-  required: z12.boolean().default(false)
-});
-var DslSchema = z12.object({
-  version: z12.literal(1),
-  extends: z12.string().optional(),
+var ScopeNodeTypeSchema = z13.enum(SCOPE_NODE_TYPES);
+var XExtensionDeclSchema = z13.object({
+  type: z13.string(),
+  items: z13.string().optional(),
+  description: z13.string().optional(),
+  scope: z13.array(ScopeNodeTypeSchema).optional(),
+  schema: z13.record(z13.string(), z13.any()).optional(),
+  required: z13.boolean().default(false)
+});
+var DslSchema = z13.object({
+  version: z13.literal(1),
+  extends: z13.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({}),
+  agents: z13.record(z13.string(), AgentSchema).default({}),
+  tasks: z13.record(z13.string(), TaskSchema).default({}),
+  artifacts: z13.record(z13.string(), ArtifactSchema).default({}),
+  tools: z13.record(z13.string(), ToolSchema).default({}),
+  validations: z13.record(z13.string(), ValidationSchema).default({}),
+  handoff_types: z13.record(z13.string(), HandoffTypeSchema).default({}),
+  workflow: z13.record(z13.string(), WorkflowSchema).default({}),
+  policies: z13.record(z13.string(), PolicySchema).default({}),
+  guardrails: z13.record(z13.string(), GuardrailSchema).default({}),
+  guardrail_policies: z13.record(z13.string(), GuardrailPolicySchema).default({}),
   components: ComponentsSchema.default({ schemas: {} }),
-  extensions: z12.record(z12.string(), XExtensionDeclSchema).default({}),
-  extensions_strict: z12.boolean().default(false)
+  extensions: z13.record(z13.string(), XExtensionDeclSchema).default({}),
+  extensions_strict: z13.boolean().default(false)
 }).passthrough();
 
 // src/schema/json-schema-utils.ts
@@ -50845,22 +50895,22 @@ function resolveAllOf(schema) {
 }
 
 // src/schema/merge-operators.ts
-import { z as z13 } from "zod";
-var AppendOperatorSchema = z13.object({
-  $append: z13.record(z13.string(), z13.any())
+import { z as z14 } from "zod";
+var AppendOperatorSchema = z14.object({
+  $append: z14.record(z14.string(), z14.any())
 });
-var PrependOperatorSchema = z13.object({
-  $prepend: z13.record(z13.string(), z13.any())
+var PrependOperatorSchema = z14.object({
+  $prepend: z14.record(z14.string(), z14.any())
 });
-var InsertAfterOperatorSchema = z13.object({
-  $insert_after: z13.object({
-    after: z13.string(),
-    entries: z13.record(z13.string(), z13.any())
+var InsertAfterOperatorSchema = z14.object({
+  $insert_after: z14.object({
+    after: z14.string(),
+    entries: z14.record(z14.string(), z14.any())
   })
 });
-var ReplaceOperatorSchema = z13.object({ $replace: z13.any() });
-var RemoveOperatorSchema = z13.object({
-  $remove: z13.array(z13.string())
+var ReplaceOperatorSchema = z14.object({ $replace: z14.any() });
+var RemoveOperatorSchema = z14.object({
+  $remove: z14.array(z14.string())
 });
 
 // src/loader/loader.ts
@@ -51476,16 +51526,16 @@ function expandDefaults(data) {
 
 // src/validator/schema-validator.ts
 import Ajv from "ajv";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function unwrap(schema) {
-  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());
+  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 z14.ZodObject) {
+  if (inner instanceof z15.ZodObject) {
     if (typeof data !== "object" || data === null || Array.isArray(data)) return [];
     const obj = data;
     const shape = inner.shape;
@@ -51506,7 +51556,7 @@ function checkCustomPropsRecursive(data, schema, path) {
     }
     return diagnostics;
   }
-  if (inner instanceof z14.ZodRecord) {
+  if (inner instanceof z15.ZodRecord) {
     if (typeof data !== "object" || data === null || Array.isArray(data)) return [];
     const valueSchema = inner._def.valueType;
     const diagnostics = [];
@@ -51515,7 +51565,7 @@ function checkCustomPropsRecursive(data, schema, path) {
     }
     return diagnostics;
   }
-  if (inner instanceof z14.ZodArray) {
+  if (inner instanceof z15.ZodArray) {
     if (!Array.isArray(data)) return [];
     const diagnostics = [];
     for (let i3 = 0; i3 < data.length; i3++) {
@@ -51523,14 +51573,14 @@ function checkCustomPropsRecursive(data, schema, path) {
     }
     return diagnostics;
   }
-  if (inner instanceof z14.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 z14.ZodLiteral && shape[disc].value === discValue;
+      return shape[disc] instanceof z15.ZodLiteral && shape[disc].value === discValue;
     });
     if (match) return checkCustomPropsRecursive(data, match, path);
     return [];
@@ -55339,31 +55389,14 @@ import { resolve as resolve4, dirname as dirname4 } from "path";
 import { parse as parseYaml2 } from "yaml";
 
 // src/config/types.ts
-import { z as z16 } from "zod";
-var CONTEXT_TYPES = [
-  "agent",
-  "task",
-  "artifact",
-  "tool",
-  "validation",
-  "handoff_type",
-  "workflow",
-  "policy",
-  "guardrail",
-  "guardrail_policy",
-  "system"
-];
-var ContextTypeSchema = z16.enum(CONTEXT_TYPES);
-var ITERABLE_CONTEXT_TYPES = CONTEXT_TYPES.filter(
-  (t3) => t3 !== "system"
-);
-var RenderTargetSchema = z16.object({
-  template: z16.string(),
+import { z as z17 } from "zod";
+var RenderTargetSchema = z17.object({
+  template: z17.string(),
   context: ContextTypeSchema,
-  output: z16.string(),
-  include: z16.array(z16.string()).optional(),
-  exclude: z16.array(z16.string()).optional(),
-  skip_empty: z16.boolean().optional()
+  output: z17.string(),
+  include: z17.array(z17.string()).optional(),
+  exclude: z17.array(z17.string()).optional(),
+  skip_empty: z17.boolean().optional()
 }).refine(
   (data) => !(data.include && data.exclude),
   { message: "include and exclude are mutually exclusive" }
@@ -55376,13 +55409,13 @@ var RenderTargetSchema = z16.object({
   },
   { message: "include/exclude cannot be used with context: system" }
 );
-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()
+var AgentContractsConfigSchema = z17.object({
+  dsl: z17.string(),
+  vars: z17.record(z17.string(), z17.string()).optional(),
+  renders: z17.array(RenderTargetSchema).default([]),
+  bindings: z17.array(z17.string()).default([]),
+  active_guardrail_policy: z17.string().optional(),
+  paths: z17.record(z17.string(), z17.string()).optional()
 });
 
 // src/config/loader.ts
@@ -55473,11 +55506,12 @@ function resolveDslPath(dirArg, dirArgDefault, config) {
 function isRecord4(v2) {
   return typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
 }
-var BINDING_MERGE_SECTIONS = ["guardrail_impl", "outputs"];
+var BINDING_MAP_MERGE_SECTIONS = ["guardrail_impl", "outputs"];
+var BINDING_ARRAY_MERGE_SECTIONS = ["renders"];
 function mergeBinding(base, project) {
   const hasExtends = typeof project["extends"] === "string";
   const result = { ...base, ...project };
-  for (const section of BINDING_MERGE_SECTIONS) {
+  for (const section of BINDING_MAP_MERGE_SECTIONS) {
     const baseVal = base[section];
     const projVal = project[section];
     if (projVal === void 0) {
@@ -55491,6 +55525,14 @@ function mergeBinding(base, project) {
       hasExtends
     );
   }
+  for (const section of BINDING_ARRAY_MERGE_SECTIONS) {
+    const baseVal = base[section];
+    const projVal = project[section];
+    if (projVal === void 0) continue;
+    const baseArr = Array.isArray(baseVal) ? baseVal : [];
+    const projArr = Array.isArray(projVal) ? projVal : [];
+    result[section] = [...baseArr, ...projArr];
+  }
   if (project["reporting"] !== void 0 && isRecord4(base["reporting"]) && isRecord4(project["reporting"])) {
     result["reporting"] = deepMergeEntities(
       base["reporting"],
@@ -56113,7 +56155,7 @@ async function generateGuardrails(options) {
     if (filterBindings && !filterBindings.includes(binding.software)) {
       continue;
     }
-    if (!binding.outputs) continue;
+    if (!binding.outputs && !binding.renders) continue;
     const checkResult = resolveChecks(dsl, binding, policy);
     diagnostics.push(...checkResult.diagnostics);
     const ctx = {
@@ -56125,9 +56167,14 @@ async function generateGuardrails(options) {
       vars,
       paths,
       reporting,
-      resolved_checks: checkResult.resolved
-    };
-    for (const [outputId, outputDef] of Object.entries(binding.outputs)) {
+      resolved_checks: checkResult.resolved,
+      tasks: dsl.tasks,
+      artifacts: dsl.artifacts,
+      agents: dsl.agents,
+      handoff_types: dsl.handoff_types,
+      workflow: dsl.workflow
+    };
+    for (const [outputId, outputDef] of Object.entries(binding.outputs ?? {})) {
       const pathResult = resolveBindingTargetPath(
         outputDef.target,
         paths,
@@ -56257,9 +56304,98 @@ async function generateGuardrails(options) {
         }
       }
     }
+    for (const renderTarget of binding.renders ?? []) {
+      let templateContent;
+      if (renderTarget.inline_template) {
+        templateContent = renderTarget.inline_template;
+      } else if (renderTarget.template) {
+        const templatePath = resolve6(config.configDir, renderTarget.template);
+        try {
+          templateContent = await readFile5(templatePath, "utf8");
+        } catch {
+          diagnostics.push({
+            path: `binding.${binding.software}.renders`,
+            message: `Template file not found: ${templatePath}`,
+            severity: "error"
+          });
+          continue;
+        }
+      } else {
+        diagnostics.push({
+          path: `binding.${binding.software}.renders`,
+          message: "Render target has neither template nor inline_template",
+          severity: "error"
+        });
+        continue;
+      }
+      const compiled = Handlebars2.compile(templateContent, { noEscape: true });
+      const shouldSkipEmpty = renderTarget.skip_empty === true;
+      const context = renderTarget.context;
+      if (context === "system") {
+        const sysCtx = buildSystemContext(dsl);
+        const mergedCtx = { ...sysCtx, vars, paths, binding, resolved_checks: checkResult.resolved };
+        const rendered = compiled(mergedCtx);
+        const resolvedOutput = resolveBindingRenderOutputPath(renderTarget.output, paths);
+        const outputPath = resolve6(config.configDir, resolvedOutput);
+        if (shouldSkipEmpty && rendered.trim().length === 0) {
+          if (!dryRun) {
+            try {
+              await unlink2(outputPath);
+            } catch {
+            }
+          }
+          continue;
+        }
+        if (!dryRun) {
+          await mkdir2(dirname6(outputPath), { recursive: true });
+          await writeFile2(outputPath, rendered, "utf8");
+          if (renderTarget.executable) {
+            await chmod(outputPath, 493);
+          }
+        }
+        outputFiles.push(outputPath);
+      } else {
+        const section = getDslSection(dsl, context);
+        const allIds = Object.keys(section);
+        const ids = filterIds(allIds, renderTarget.include, renderTarget.exclude);
+        for (const entityId of ids) {
+          const entityCtx = buildEntityContext(dsl, context, entityId);
+          const mergedCtx = { ...entityCtx, vars, paths, binding, resolved_checks: checkResult.resolved };
+          const rendered = compiled(mergedCtx);
+          const resolvedOutput = resolveBindingRenderOutputPath(
+            expandOutputPath(renderTarget.output, context, entityId),
+            paths
+          );
+          const outputPath = resolve6(config.configDir, resolvedOutput);
+          if (shouldSkipEmpty && rendered.trim().length === 0) {
+            if (!dryRun) {
+              try {
+                await unlink2(outputPath);
+              } catch {
+              }
+            }
+            continue;
+          }
+          if (!dryRun) {
+            await mkdir2(dirname6(outputPath), { recursive: true });
+            await writeFile2(outputPath, rendered, "utf8");
+            if (renderTarget.executable) {
+              await chmod(outputPath, 493);
+            }
+          }
+          outputFiles.push(outputPath);
+        }
+      }
+    }
   }
   return { outputFiles, diagnostics };
 }
+function resolveBindingRenderOutputPath(output, paths) {
+  return output.replace(/\{(\w+)\}/g, (match, varName) => {
+    const value = paths[varName];
+    return value !== void 0 ? value : match;
+  });
+}
 export {
   AgentContractsConfigSchema,
   AgentSchema,
@@ -56267,6 +56403,7 @@ export {
   ArtifactSchema,
   BaseResolveError,
   BindingOutputSchema,
+  BindingRenderTargetSchema,
   CONTEXT_TYPES,
   CheckSchema,
   CommandSchema,
@@ -56284,6 +56421,7 @@ export {
   GuardrailSchema,
   GuardrailScopeSchema,
   HandoffTypeSchema,
+  ITERABLE_CONTEXT_TYPES,
   InsertAfterOperatorSchema,
   MatcherSchema,
   MergeError,