agent-contracts 0.14.1 → 0.16.0

package/dist/index.js

@@ -6292,7 +6292,7 @@ var init_index_es = __esm({
         return { drive: t4.toLowerCase() + ":" };
       }, k2 = function() {
         return { drive: null };
-      }, z18 = function() {
+      }, z20 = 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 = z18()), t5;
+            return (t5 = x3) !== c2 && (t5 = z20()), 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: () => z16,
+  resolveInlineRefWithLocation: () => z18,
   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 z16(e3, t3).value;
+  return z18(e3, t3).value;
 }
-function z16(e3, t3) {
+function z18(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 z18(n4, r4) {
+    function z20(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 = z18(r5, t4);
+        var e5, i5 = z20(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 = z18(s2(n4), r4);
+      var e4 = z20(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 z18 = new Array(need + 1).join("0");
+                var z20 = new Array(need + 1).join("0");
                 if (i3 < 0)
-                  c2 = "-" + z18 + c2.slice(1);
+                  c2 = "-" + z20 + c2.slice(1);
                 else
-                  c2 = z18 + c2;
+                  c2 = z20 + 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, z18) => zs.concat(z18), xs)
+      (xs) => (ys) => ys.reduce((zs, z20) => zs.concat(z20), xs)
     );
     function getLastSegment(instancePath) {
       const index4 = instancePath.lastIndexOf("/");
@@ -50602,7 +50602,7 @@ var SoftwareBindingSchema = z4.object({
 }).passthrough();
 
 // src/schema/dsl.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 
 // src/schema/handoff-type.ts
 import { z as z5 } from "zod";
@@ -50703,106 +50703,143 @@ var TaskSchema = z9.object({
   guardrails: z9.array(z9.string()).optional()
 }).passthrough();
 
-// src/schema/tool.ts
+// src/schema/team-import.ts
 import { z as z10 } from "zod";
-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()
+var TeamImportSchema = z10.object({
+  interface: z10.string(),
+  version: z10.string().optional()
 }).passthrough();
 
-// src/schema/validation.ts
+// src/schema/team-interface.ts
 import { z as z11 } from "zod";
-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()
+var TeamInterfaceAcceptWorkflowSchema = z11.object({
+  internal_workflow: z11.string().optional(),
+  input_handoff: z11.string(),
+  output_handoff: z11.string(),
+  description: z11.string().optional()
+}).passthrough();
+var TeamInterfaceSchema = z11.object({
+  version: z11.number(),
+  description: z11.string().optional(),
+  accepts: z11.object({
+    workflows: z11.record(z11.string(), TeamInterfaceAcceptWorkflowSchema)
+  }).passthrough().optional(),
+  exposes: z11.object({
+    artifacts: z11.array(z11.string())
+  }).passthrough().optional(),
+  constraints: z11.array(z11.string()).optional()
 }).passthrough();
 
-// src/schema/workflow.ts
+// src/schema/tool.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"),
+var CommandSchema = z12.object({
+  command: z12.string(),
+  category: z12.string(),
+  reads: z12.array(z12.string()).default([]),
+  writes: z12.array(z12.string()).default([]),
+  purpose: z12.string().optional()
+});
+var ToolSchema = z12.object({
+  kind: z12.string(),
   description: z12.string().optional(),
-  task: z12.string(),
-  from_agent: z12.string(),
-  group: z12.string().optional(),
+  input_artifacts: z12.array(z12.string()).default([]),
+  output_artifacts: z12.array(z12.string()).default([]),
+  invokable_by: z12.array(z12.string()),
+  side_effects: z12.array(z12.string()).default([]),
+  commands: z12.array(CommandSchema).default([]),
+  guardrails: z12.array(z12.string()).optional()
+}).passthrough();
+
+// src/schema/validation.ts
+import { z as z13 } from "zod";
+var ValidationSchema = z13.object({
+  target_artifact: z13.string(),
+  kind: z13.enum(["schema", "mechanical", "semantic", "approval", "provenance", "traceability", "fidelity"]),
+  executor_type: z13.enum(["tool", "agent"]),
+  executor: z13.string(),
+  blocking: z13.boolean(),
+  produces_evidence: z13.string().optional()
+}).passthrough();
+
+// src/schema/workflow.ts
+import { z as z14 } from "zod";
+var RetrySchema = z14.object({
+  condition: z14.string(),
+  fix_task: z14.string(),
+  revalidate_task: z14.string().optional()
+});
+var ExternalParticipantSchema = z14.object({
+  id: z14.string(),
+  kind: z14.enum(["actor", "participant"]),
+  label: z14.string(),
+  description: z14.string().optional()
+});
+var WorkflowDelegateStepSchema = z14.object({
+  type: z14.literal("delegate"),
+  description: z14.string().optional(),
+  task: z14.string(),
+  from_agent: z14.string(),
+  group: z14.string().optional(),
   retry: RetrySchema.optional()
 }).passthrough();
-var WorkflowGateStepSchema = z12.object({
-  type: z12.literal("gate"),
-  description: z12.string().optional(),
-  gate_kind: z12.string(),
-  group: z12.string().optional()
+var WorkflowGateStepSchema = z14.object({
+  type: z14.literal("gate"),
+  description: z14.string().optional(),
+  gate_kind: z14.string(),
+  group: z14.string().optional()
 }).passthrough();
-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(),
+var WorkflowHandoffStepSchema = z14.object({
+  type: z14.literal("handoff"),
+  description: z14.string().optional(),
+  handoff_kind: z14.string(),
+  task: z14.string().optional(),
+  from_agent: z14.string().optional(),
+  group: z14.string().optional(),
   retry: RetrySchema.optional()
 }).passthrough();
-var WorkflowValidationStepSchema = z12.object({
-  type: z12.literal("validation"),
-  description: z12.string().optional(),
-  validation: z12.string(),
-  group: z12.string().optional()
+var WorkflowValidationStepSchema = z14.object({
+  type: z14.literal("validation"),
+  description: z14.string().optional(),
+  validation: z14.string(),
+  group: z14.string().optional()
 }).passthrough();
-var WorkflowDecisionStepSchema = z12.object({
-  type: z12.literal("decision"),
-  description: z12.string().optional(),
+var WorkflowDecisionStepSchema = z14.object({
+  type: z14.literal("decision"),
+  description: z14.string().optional(),
   /** @deprecated Use `routing_key` instead. `on` is kept for backward compatibility. */
-  on: z12.string().optional(),
-  routing_key: z12.string().optional(),
-  branches: z12.record(z12.string(), z12.array(z12.string())),
-  group: z12.string().optional()
+  on: z14.string().optional(),
+  routing_key: z14.string().optional(),
+  branches: z14.record(z14.string(), z14.array(z14.string())),
+  group: z14.string().optional()
 }).passthrough();
-var WorkflowStepSchema = z12.discriminatedUnion("type", [
+var WorkflowTeamTaskStepSchema = z14.object({
+  type: z14.literal("team_task"),
+  description: z14.string().optional(),
+  to_team: z14.string(),
+  workflow: z14.string(),
+  handoff: z14.string(),
+  expects: z14.string(),
+  group: z14.string().optional()
+}).passthrough();
+var WorkflowStepSchema = z14.discriminatedUnion("type", [
   WorkflowDelegateStepSchema,
   WorkflowGateStepSchema,
   WorkflowHandoffStepSchema,
   WorkflowValidationStepSchema,
-  WorkflowDecisionStepSchema
+  WorkflowDecisionStepSchema,
+  WorkflowTeamTaskStepSchema
 ]);
-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([])
+var WorkflowSchema = z14.object({
+  description: z14.string().optional(),
+  entry_conditions: z14.array(z14.string()).default([]),
+  trigger: z14.string().optional(),
+  steps: z14.array(WorkflowStepSchema),
+  external_participants: z14.array(ExternalParticipantSchema).default([])
 }).passthrough();
 
 // src/schema/dsl.ts
-var ComponentsSchema = z13.object({
-  schemas: z13.record(z13.string(), z13.record(z13.string(), z13.any())).default({})
+var ComponentsSchema = z15.object({
+  schemas: z15.record(z15.string(), z15.record(z15.string(), z15.any())).default({})
 }).passthrough();
 var SCOPE_NODE_TYPES = [
   "root",
@@ -50824,32 +50861,34 @@ var SCOPE_NODE_TYPES = [
   "escalation_criterion",
   "prerequisite"
 ];
-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(),
+var ScopeNodeTypeSchema = z15.enum(SCOPE_NODE_TYPES);
+var XExtensionDeclSchema = z15.object({
+  type: z15.string(),
+  items: z15.string().optional(),
+  description: z15.string().optional(),
+  scope: z15.array(ScopeNodeTypeSchema).optional(),
+  schema: z15.record(z15.string(), z15.any()).optional(),
+  required: z15.boolean().default(false)
+});
+var DslSchema = z15.object({
+  version: z15.literal(1),
+  extends: z15.string().optional(),
   system: SystemSchema,
-  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({}),
+  agents: z15.record(z15.string(), AgentSchema).default({}),
+  tasks: z15.record(z15.string(), TaskSchema).default({}),
+  artifacts: z15.record(z15.string(), ArtifactSchema).default({}),
+  tools: z15.record(z15.string(), ToolSchema).default({}),
+  validations: z15.record(z15.string(), ValidationSchema).default({}),
+  handoff_types: z15.record(z15.string(), HandoffTypeSchema).default({}),
+  team_interface: TeamInterfaceSchema.optional(),
+  imports: z15.record(z15.string(), TeamImportSchema).optional(),
+  workflow: z15.record(z15.string(), WorkflowSchema).default({}),
+  policies: z15.record(z15.string(), PolicySchema).default({}),
+  guardrails: z15.record(z15.string(), GuardrailSchema).default({}),
+  guardrail_policies: z15.record(z15.string(), GuardrailPolicySchema).default({}),
   components: ComponentsSchema.default({ schemas: {} }),
-  extensions: z13.record(z13.string(), XExtensionDeclSchema).default({}),
-  extensions_strict: z13.boolean().default(false)
+  extensions: z15.record(z15.string(), XExtensionDeclSchema).default({}),
+  extensions_strict: z15.boolean().default(false)
 }).passthrough();
 
 // src/schema/json-schema-utils.ts
@@ -50901,22 +50940,22 @@ function resolveAllOf(schema) {
 }
 
 // src/schema/merge-operators.ts
-import { z as z14 } from "zod";
-var AppendOperatorSchema = z14.object({
-  $append: z14.record(z14.string(), z14.any())
+import { z as z16 } from "zod";
+var AppendOperatorSchema = z16.object({
+  $append: z16.record(z16.string(), z16.any())
 });
-var PrependOperatorSchema = z14.object({
-  $prepend: z14.record(z14.string(), z14.any())
+var PrependOperatorSchema = z16.object({
+  $prepend: z16.record(z16.string(), z16.any())
 });
-var InsertAfterOperatorSchema = z14.object({
-  $insert_after: z14.object({
-    after: z14.string(),
-    entries: z14.record(z14.string(), z14.any())
+var InsertAfterOperatorSchema = z16.object({
+  $insert_after: z16.object({
+    after: z16.string(),
+    entries: z16.record(z16.string(), z16.any())
   })
 });
-var ReplaceOperatorSchema = z14.object({ $replace: z14.any() });
-var RemoveOperatorSchema = z14.object({
-  $remove: z14.array(z14.string())
+var ReplaceOperatorSchema = z16.object({ $replace: z16.any() });
+var RemoveOperatorSchema = z16.object({
+  $remove: z16.array(z16.string())
 });
 
 // src/loader/loader.ts
@@ -51464,6 +51503,7 @@ var MERGE_SECTIONS = [
   "tools",
   "validations",
   "handoff_types",
+  "imports",
   "workflow",
   "policies",
   "guardrails",
@@ -51532,16 +51572,16 @@ function expandDefaults(data) {
 
 // src/validator/schema-validator.ts
 import Ajv from "ajv";
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 function unwrap(schema) {
-  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());
+  if (schema instanceof z17.ZodOptional) return unwrap(schema.unwrap());
+  if (schema instanceof z17.ZodDefault) return unwrap(schema.removeDefault());
+  if (schema instanceof z17.ZodNullable) return unwrap(schema.unwrap());
   return schema;
 }
 function checkCustomPropsRecursive(data, schema, path) {
   const inner = unwrap(schema);
-  if (inner instanceof z15.ZodObject) {
+  if (inner instanceof z17.ZodObject) {
     if (typeof data !== "object" || data === null || Array.isArray(data)) return [];
     const obj = data;
     const shape = inner.shape;
@@ -51562,7 +51602,7 @@ function checkCustomPropsRecursive(data, schema, path) {
     }
     return diagnostics;
   }
-  if (inner instanceof z15.ZodRecord) {
+  if (inner instanceof z17.ZodRecord) {
     if (typeof data !== "object" || data === null || Array.isArray(data)) return [];
     const valueSchema = inner._def.valueType;
     const diagnostics = [];
@@ -51571,7 +51611,7 @@ function checkCustomPropsRecursive(data, schema, path) {
     }
     return diagnostics;
   }
-  if (inner instanceof z15.ZodArray) {
+  if (inner instanceof z17.ZodArray) {
     if (!Array.isArray(data)) return [];
     const diagnostics = [];
     for (let i3 = 0; i3 < data.length; i3++) {
@@ -51579,14 +51619,14 @@ function checkCustomPropsRecursive(data, schema, path) {
     }
     return diagnostics;
   }
-  if (inner instanceof z15.ZodDiscriminatedUnion) {
+  if (inner instanceof z17.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 z15.ZodLiteral && shape[disc].value === discValue;
+      return shape[disc] instanceof z17.ZodLiteral && shape[disc].value === discValue;
     });
     if (match) return checkCustomPropsRecursive(data, match, path);
     return [];
@@ -52388,6 +52428,25 @@ function checkReferences(dsl) {
         }
       } else if (step.type === "validation") {
         checkExists(step.validation, validationIds, "validations", `workflow.${wfId}.steps[${j2}].validation`);
+      } else if (step.type === "team_task") {
+        const importKeys = dsl.imports !== void 0 ? new Set(Object.keys(dsl.imports)) : null;
+        if (importKeys) {
+          checkExists(
+            step.to_team,
+            importKeys,
+            "imports",
+            `workflow.${wfId}.steps[${j2}].to_team`,
+            "team-import-not-found"
+          );
+        } else {
+          diagnostics.push({
+            path: `workflow.${wfId}.steps[${j2}].to_team`,
+            message: `team_task step references team "${step.to_team}" but dsl.imports is not defined`,
+            code: "team-task-missing-imports"
+          });
+        }
+        checkExists(step.handoff, handoffKinds, "handoff_types", `workflow.${wfId}.steps[${j2}].handoff`);
+        checkExists(step.expects, handoffKinds, "handoff_types", `workflow.${wfId}.steps[${j2}].expects`);
       }
     }
   }
@@ -52565,6 +52624,48 @@ function checkReferences(dsl) {
       );
     }
   }
+  const workflowDefinitionIds = new Set(Object.keys(dsl.workflow));
+  if (dsl.team_interface) {
+    const ti = dsl.team_interface;
+    if (ti.accepts?.workflows) {
+      for (const [wfKey, spec] of Object.entries(ti.accepts.workflows)) {
+        const internalWf = spec.internal_workflow ?? wfKey;
+        checkExists(
+          internalWf,
+          workflowDefinitionIds,
+          "workflow",
+          `team_interface.accepts.workflows.${wfKey}.internal_workflow`,
+          "team-interface-workflow-not-found"
+        );
+        checkExists(
+          spec.input_handoff,
+          handoffKinds,
+          "handoff_types",
+          `team_interface.accepts.workflows.${wfKey}.input_handoff`,
+          "team-interface-handoff-not-found"
+        );
+        checkExists(
+          spec.output_handoff,
+          handoffKinds,
+          "handoff_types",
+          `team_interface.accepts.workflows.${wfKey}.output_handoff`,
+          "team-interface-handoff-not-found"
+        );
+      }
+    }
+    if (ti.exposes?.artifacts) {
+      for (let i3 = 0; i3 < ti.exposes.artifacts.length; i3++) {
+        const artKey = ti.exposes.artifacts[i3];
+        checkExists(
+          artKey,
+          artifactIds,
+          "artifacts",
+          `team_interface.exposes.artifacts[${i3}]`,
+          "team-interface-artifact-not-found"
+        );
+      }
+    }
+  }
   return diagnostics;
 }
 
@@ -55395,14 +55496,14 @@ import { resolve as resolve4, dirname as dirname4 } from "path";
 import { parse as parseYaml2 } from "yaml";
 
 // src/config/types.ts
-import { z as z17 } from "zod";
-var RenderTargetSchema = z17.object({
-  template: z17.string(),
+import { z as z19 } from "zod";
+var RenderTargetSchema = z19.object({
+  template: z19.string(),
   context: ContextTypeSchema,
-  output: z17.string(),
-  include: z17.array(z17.string()).optional(),
-  exclude: z17.array(z17.string()).optional(),
-  skip_empty: z17.boolean().optional()
+  output: z19.string(),
+  include: z19.array(z19.string()).optional(),
+  exclude: z19.array(z19.string()).optional(),
+  skip_empty: z19.boolean().optional()
 }).refine(
   (data) => !(data.include && data.exclude),
   { message: "include and exclude are mutually exclusive" }
@@ -55415,13 +55516,51 @@ var RenderTargetSchema = z17.object({
   },
   { message: "include/exclude cannot be used with context: system" }
 );
-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()
+var TeamConfigSchema = z19.object({
+  dsl: z19.string().optional(),
+  bindings: z19.array(z19.string()).default([]),
+  vars: z19.record(z19.string(), z19.string()).optional(),
+  paths: z19.record(z19.string(), z19.string()).optional(),
+  active_guardrail_policy: z19.string().optional(),
+  interface_output: z19.string().optional()
+});
+var AgentContractsConfigSchema = z19.object({
+  dsl: z19.string().optional(),
+  vars: z19.record(z19.string(), z19.string()).optional(),
+  renders: z19.array(RenderTargetSchema).default([]),
+  bindings: z19.array(z19.string()).default([]),
+  active_guardrail_policy: z19.string().optional(),
+  paths: z19.record(z19.string(), z19.string()).optional(),
+  teams: z19.record(z19.string(), TeamConfigSchema).optional()
+}).superRefine((data, ctx) => {
+  if (data.dsl !== void 0 && data.teams !== void 0) {
+    ctx.addIssue({
+      code: z19.ZodIssueCode.custom,
+      message: "dsl and teams are mutually exclusive",
+      path: ["teams"]
+    });
+    return;
+  }
+  if (data.dsl === void 0 && data.teams === void 0) {
+    ctx.addIssue({
+      code: z19.ZodIssueCode.custom,
+      message: "Either dsl or teams must be specified",
+      path: []
+    });
+    return;
+  }
+  if (data.teams) {
+    for (const [key, team] of Object.entries(data.teams)) {
+      if (key === "_defaults") continue;
+      if (team.dsl === void 0) {
+        ctx.addIssue({
+          code: z19.ZodIssueCode.custom,
+          message: `Team "${key}" must specify dsl`,
+          path: ["teams", key, "dsl"]
+        });
+      }
+    }
+  }
 });
 
 // src/config/loader.ts
@@ -55442,6 +55581,27 @@ async function fileExists2(filePath) {
     return false;
   }
 }
+function resolveTeamConfigs(teams, configDir) {
+  const defaults = teams._defaults;
+  const result = {};
+  for (const [key, team] of Object.entries(teams)) {
+    if (key === "_defaults") continue;
+    const mergedBindings = [...defaults?.bindings ?? [], ...team.bindings].map(
+      (b3) => resolve4(configDir, b3)
+    );
+    const mergedVars = defaults?.vars || team.vars ? { ...defaults?.vars ?? {}, ...team.vars ?? {} } : void 0;
+    const mergedPaths = defaults?.paths || team.paths ? { ...defaults?.paths ?? {}, ...team.paths ?? {} } : void 0;
+    result[key] = {
+      dsl: resolve4(configDir, team.dsl),
+      bindings: mergedBindings,
+      vars: mergedVars,
+      activeGuardrailPolicy: team.active_guardrail_policy ?? defaults?.active_guardrail_policy,
+      paths: mergedPaths,
+      interfaceOutput: team.interface_output ? resolve4(configDir, team.interface_output) : void 0
+    };
+  }
+  return result;
+}
 async function loadConfig(configPath) {
   const isExplicit = configPath !== void 0;
   const targetPath = resolve4(configPath ?? DEFAULT_CONFIG_NAME);
@@ -55484,14 +55644,27 @@ ${issues}`,
   }
   const configDir = dirname4(targetPath);
   const config = result.data;
+  const renders = config.renders.map((r3) => ({
+    ...r3,
+    template: resolve4(configDir, r3.template),
+    output: resolve4(configDir, r3.output)
+  }));
+  if (config.teams) {
+    return {
+      dsl: "",
+      vars: void 0,
+      renders,
+      configDir,
+      bindings: [],
+      activeGuardrailPolicy: void 0,
+      paths: void 0,
+      teams: resolveTeamConfigs(config.teams, configDir)
+    };
+  }
   return {
     dsl: resolve4(configDir, config.dsl),
     vars: config.vars,
-    renders: config.renders.map((r3) => ({
-      ...r3,
-      template: resolve4(configDir, r3.template),
-      output: resolve4(configDir, r3.output)
-    })),
+    renders,
     configDir,
     bindings: (config.bindings ?? []).map((b3) => resolve4(configDir, b3)),
     activeGuardrailPolicy: config.active_guardrail_policy,
@@ -56445,6 +56618,9 @@ export {
   SoftwareBindingSchema,
   SystemSchema,
   TaskSchema,
+  TeamImportSchema,
+  TeamInterfaceAcceptWorkflowSchema,
+  TeamInterfaceSchema,
   ToolSchema,
   ValidationSchema,
   VersionLiteralSchema,