agent-contracts 0.23.3 → 0.24.1

package/dist/index.d.ts

@@ -106,15 +106,33 @@ type Agent = z.infer<typeof AgentSchema>;
 declare const ArtifactSchema: z.ZodObject<{
     type: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    owner: z.ZodString;
-    producers: z.ZodArray<z.ZodString>;
-    editors: z.ZodArray<z.ZodString>;
-    consumers: z.ZodArray<z.ZodString>;
-    states: z.ZodArray<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    producers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    editors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    consumers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    states: z.ZodDefault<z.ZodArray<z.ZodString>>;
     required_validations: z.ZodDefault<z.ZodArray<z.ZodString>>;
     visibility: z.ZodOptional<z.ZodString>;
     classification: z.ZodOptional<z.ZodString>;
     guardrails: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    authority: z.ZodOptional<z.ZodEnum<{
+        canonical: "canonical";
+        derived: "derived";
+        generated: "generated";
+        control: "control";
+    }>>;
+    path_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    manual_edit: z.ZodOptional<z.ZodEnum<{
+        allowed: "allowed";
+        discouraged: "discouraged";
+        forbidden: "forbidden";
+    }>>;
+    change_control: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        "approval-required": "approval-required";
+        "regeneration-required": "regeneration-required";
+    }>>;
 }, z.core.$loose>;
 type Artifact = z.infer<typeof ArtifactSchema>;
 
@@ -501,22 +519,40 @@ declare const DslSchema: z.ZodObject<{
     artifacts: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         type: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
-        owner: z.ZodString;
-        producers: z.ZodArray<z.ZodString>;
-        editors: z.ZodArray<z.ZodString>;
-        consumers: z.ZodArray<z.ZodString>;
-        states: z.ZodArray<z.ZodString>;
+        owner: z.ZodOptional<z.ZodString>;
+        producers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        editors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        consumers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        states: z.ZodDefault<z.ZodArray<z.ZodString>>;
         required_validations: z.ZodDefault<z.ZodArray<z.ZodString>>;
         visibility: z.ZodOptional<z.ZodString>;
         classification: z.ZodOptional<z.ZodString>;
         guardrails: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        authority: z.ZodOptional<z.ZodEnum<{
+            canonical: "canonical";
+            derived: "derived";
+            generated: "generated";
+            control: "control";
+        }>>;
+        path_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exclude_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        manual_edit: z.ZodOptional<z.ZodEnum<{
+            allowed: "allowed";
+            discouraged: "discouraged";
+            forbidden: "forbidden";
+        }>>;
+        change_control: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            "approval-required": "approval-required";
+            "regeneration-required": "regeneration-required";
+        }>>;
     }, z.core.$loose>>>;
     tools: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         kind: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         input_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
         output_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        invokable_by: z.ZodArray<z.ZodString>;
+        invokable_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
         side_effects: z.ZodDefault<z.ZodArray<z.ZodString>>;
         commands: z.ZodDefault<z.ZodArray<z.ZodObject<{
             command: z.ZodString;
@@ -1035,7 +1071,7 @@ declare const ToolSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     input_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
     output_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    invokable_by: z.ZodArray<z.ZodString>;
+    invokable_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
     side_effects: z.ZodDefault<z.ZodArray<z.ZodString>>;
     commands: z.ZodDefault<z.ZodArray<z.ZodObject<{
         command: z.ZodString;

package/dist/index.js

@@ -48942,15 +48942,20 @@ import { z as z2 } from "zod";
 var ArtifactSchema = z2.object({
   type: z2.string(),
   description: z2.string().optional(),
-  owner: z2.string(),
-  producers: z2.array(z2.string()),
-  editors: z2.array(z2.string()),
-  consumers: z2.array(z2.string()),
-  states: z2.array(z2.string()),
+  owner: z2.string().optional(),
+  producers: z2.array(z2.string()).default([]),
+  editors: z2.array(z2.string()).default([]),
+  consumers: z2.array(z2.string()).default([]),
+  states: z2.array(z2.string()).default([]),
   required_validations: z2.array(z2.string()).default([]),
   visibility: z2.string().optional(),
   classification: z2.string().optional(),
-  guardrails: z2.array(z2.string()).optional()
+  guardrails: z2.array(z2.string()).optional(),
+  authority: z2.enum(["canonical", "derived", "generated", "control"]).optional(),
+  path_patterns: z2.array(z2.string()).optional(),
+  exclude_patterns: z2.array(z2.string()).optional(),
+  manual_edit: z2.enum(["allowed", "discouraged", "forbidden"]).optional(),
+  change_control: z2.enum(["none", "approval-required", "regeneration-required"]).optional()
 }).passthrough();
 
 // src/schema/binding.ts
@@ -49213,7 +49218,7 @@ var ToolSchema = z12.object({
   description: z12.string().optional(),
   input_artifacts: z12.array(z12.string()).default([]),
   output_artifacts: z12.array(z12.string()).default([]),
-  invokable_by: z12.array(z12.string()),
+  invokable_by: z12.array(z12.string()).default([]),
   side_effects: z12.array(z12.string()).default([]),
   commands: z12.array(CommandSchema).default([]),
   guardrails: z12.array(z12.string()).optional()
@@ -50974,28 +50979,38 @@ function checkReferences(dsl) {
     }
   }
   for (const [id, art] of Object.entries(dsl.artifacts)) {
-    checkExists(art.owner, agentIds, "agents", `artifacts.${id}.owner`);
-    for (const ref of art.producers) {
-      checkExists(ref, agentIds, "agents", `artifacts.${id}.producers`);
+    if (art.owner) {
+      checkExists(art.owner, agentIds, "agents", `artifacts.${id}.owner`);
     }
-    for (const ref of art.editors) {
-      checkExists(ref, agentIds, "agents", `artifacts.${id}.editors`);
+    if (art.producers.length > 0) {
+      for (const ref of art.producers) {
+        checkExists(ref, agentIds, "agents", `artifacts.${id}.producers`);
+      }
+    }
+    if (art.editors.length > 0) {
+      for (const ref of art.editors) {
+        checkExists(ref, agentIds, "agents", `artifacts.${id}.editors`);
+      }
     }
-    for (const ref of art.consumers) {
-      checkExists(ref, agentIds, "agents", `artifacts.${id}.consumers`);
+    if (art.consumers.length > 0) {
+      for (const ref of art.consumers) {
+        checkExists(ref, agentIds, "agents", `artifacts.${id}.consumers`);
+      }
     }
     for (const ref of art.required_validations) {
       checkExists(ref, validationIds, "validations", `artifacts.${id}.required_validations`);
     }
   }
   for (const [id, art] of Object.entries(dsl.artifacts)) {
-    const ownerAgent = dsl.agents[art.owner];
-    if (ownerAgent && !ownerAgent.can_read_artifacts.includes(id)) {
-      diagnostics.push({
-        path: `artifacts.${id}.owner`,
-        message: `Agent "${art.owner}" owns artifact "${id}" but cannot read it (missing from can_read_artifacts)`,
-        code: "artifact-owner-no-read"
-      });
+    if (art.owner) {
+      const ownerAgent = dsl.agents[art.owner];
+      if (ownerAgent && !ownerAgent.can_read_artifacts.includes(id)) {
+        diagnostics.push({
+          path: `artifacts.${id}.owner`,
+          message: `Agent "${art.owner}" owns artifact "${id}" but cannot read it (missing from can_read_artifacts)`,
+          code: "artifact-owner-no-read"
+        });
+      }
     }
     for (const valId of art.required_validations) {
       const validation = dsl.validations[valId];
@@ -51012,8 +51027,10 @@ function checkReferences(dsl) {
     }
   }
   for (const [id, tool] of Object.entries(dsl.tools)) {
-    for (const ref of tool.invokable_by) {
-      checkExists(ref, agentIds, "agents", `tools.${id}.invokable_by`);
+    if (tool.invokable_by.length > 0) {
+      for (const ref of tool.invokable_by) {
+        checkExists(ref, agentIds, "agents", `tools.${id}.invokable_by`);
+      }
     }
   }
   for (const [id, val] of Object.entries(dsl.validations)) {
@@ -51404,10 +51421,10 @@ var toolExecutionRule = {
     for (const [agentId, agent] of Object.entries(dsl.agents)) {
       for (const toolId of agent.can_execute_tools) {
         const invokableBy = toolInvokableBy.get(toolId);
-        if (invokableBy && !invokableBy.has(agentId)) {
+        if (invokableBy && invokableBy.size > 0 && !invokableBy.has(agentId)) {
           diagnostics.push({
             ruleId: "tool-execution",
-            severity: "error",
+            severity: "warning",
             path: `agents.${agentId}.can_execute_tools`,
             message: `Agent "${agentId}" has can_execute_tools "${toolId}" but tool's invokable_by does not include "${agentId}"`
           });
@@ -51415,12 +51432,13 @@ var toolExecutionRule = {
       }
     }
     for (const [toolId, tool] of Object.entries(dsl.tools)) {
+      if (tool.invokable_by.length === 0) continue;
       for (const agentId of tool.invokable_by) {
         const agent = dsl.agents[agentId];
         if (agent && !agent.can_execute_tools.includes(toolId)) {
           diagnostics.push({
             ruleId: "tool-execution",
-            severity: "error",
+            severity: "warning",
             path: `tools.${toolId}.invokable_by`,
             message: `Tool "${toolId}" has invokable_by "${agentId}" but agent's can_execute_tools does not include "${toolId}"`
           });
@@ -51536,10 +51554,10 @@ var taskAgentBindingRule = {
             });
           }
           const tool = dsl.tools[step.uses_tool];
-          if (tool && !tool.invokable_by.includes(task.target_agent)) {
+          if (tool && tool.invokable_by.length > 0 && !tool.invokable_by.includes(task.target_agent)) {
             diagnostics.push({
               ruleId: "task-agent-binding",
-              severity: "error",
+              severity: "warning",
               path: `tasks.${taskId}.execution_steps`,
               message: `Task "${taskId}" step uses_tool "${step.uses_tool}" but tool's invokable_by does not include "${task.target_agent}"`
             });
@@ -51606,7 +51624,7 @@ var artifactOwnershipRule = {
       for (const step of task.execution_steps) {
         if (step.produces_artifact) {
           const artifact = dsl.artifacts[step.produces_artifact];
-          if (artifact) {
+          if (artifact && (artifact.producers.length > 0 || artifact.editors.length > 0)) {
             const canWrite = artifact.producers.includes(agentId) || artifact.editors.includes(agentId);
             if (!canWrite) {
               diagnostics.push({
@@ -51620,7 +51638,7 @@ var artifactOwnershipRule = {
         }
         if (step.reads_artifact) {
           const artifact = dsl.artifacts[step.reads_artifact];
-          if (artifact) {
+          if (artifact && (artifact.consumers.length > 0 || artifact.producers.length > 0 || artifact.editors.length > 0)) {
             const canRead = artifact.consumers.includes(agentId) || artifact.producers.includes(agentId) || artifact.editors.includes(agentId);
             if (!canRead) {
               diagnostics.push({
@@ -52519,9 +52537,9 @@ var ruleset = {
       }
     },
     "artifact-producers-ref": {
-      description: "Artifact producers must reference existing agents",
+      description: "(deprecated) Artifact producers must reference existing agents",
       message: "{{error}}",
-      severity: "error",
+      severity: "warn",
       given: "$.artifacts.*",
       then: {
         field: "producers",
@@ -52530,9 +52548,9 @@ var ruleset = {
       }
     },
     "artifact-editors-ref": {
-      description: "Artifact editors must reference existing agents",
+      description: "(deprecated) Artifact editors must reference existing agents",
       message: "{{error}}",
-      severity: "error",
+      severity: "warn",
       given: "$.artifacts.*",
       then: {
         field: "editors",
@@ -52541,9 +52559,9 @@ var ruleset = {
       }
     },
     "artifact-consumers-ref": {
-      description: "Artifact consumers must reference existing agents",
+      description: "(deprecated) Artifact consumers must reference existing agents",
       message: "{{error}}",
-      severity: "error",
+      severity: "warn",
       given: "$.artifacts.*",
       then: {
         field: "consumers",
@@ -52706,9 +52724,9 @@ var ruleset = {
       }
     },
     "tool-invokable-by-ref": {
-      description: "Tool invokable_by must reference existing agents",
+      description: "(deprecated) Tool invokable_by must reference existing agents",
       message: "{{error}}",
-      severity: "error",
+      severity: "warn",
       given: "$.tools.*",
       then: {
         field: "invokable_by",
@@ -52718,17 +52736,17 @@ var ruleset = {
     },
     // ========== 15.2.2 Artifact responsibility integrity ==========
     "artifact-editors-not-empty": {
-      description: "Artifact editors must not be empty (15.2.2)",
+      description: "(deprecated) Artifact editors must not be empty (15.2.2)",
       message: "{{error}}",
-      severity: "error",
+      severity: "info",
       given: "$.artifacts.*.editors",
       then: {
         function: editors_not_empty_default
       }
     },
     "artifact-owner-exists": {
-      description: "Every artifact must have an owner",
-      severity: "error",
+      description: "(deprecated) Every artifact must have an owner",
+      severity: "warn",
       given: "$.artifacts.*",
       then: {
         field: "owner",
@@ -54799,60 +54817,6 @@ function schemaCompleteness(dsl) {
     recommendations: lowSections.length > 0 ? [`Low optional field coverage in: ${lowSections.join(", ")}`] : []
   };
 }
-function crossReferenceBidirectionality(dsl) {
-  let totalChecks = 0;
-  let passedChecks = 0;
-  const issues = [];
-  for (const [agentId, agent] of Object.entries(dsl.agents)) {
-    for (const toolId of agent.can_execute_tools) {
-      totalChecks++;
-      const tool = dsl.tools[toolId];
-      if (tool && tool.invokable_by.includes(agentId)) {
-        passedChecks++;
-      } else {
-        issues.push(`agent ${agentId} \u2192 tool ${toolId}`);
-      }
-    }
-    for (const artId of agent.can_write_artifacts) {
-      totalChecks++;
-      const art = dsl.artifacts[artId];
-      if (art && (art.producers.includes(agentId) || art.editors.includes(agentId))) {
-        passedChecks++;
-      } else {
-        issues.push(`agent ${agentId} \u2192 artifact ${artId} (write)`);
-      }
-    }
-    for (const artId of agent.can_read_artifacts) {
-      totalChecks++;
-      const art = dsl.artifacts[artId];
-      if (art && (art.consumers.includes(agentId) || art.producers.includes(agentId) || art.editors.includes(agentId))) {
-        passedChecks++;
-      } else {
-        issues.push(`agent ${agentId} \u2192 artifact ${artId} (read)`);
-      }
-    }
-  }
-  for (const [toolId, tool] of Object.entries(dsl.tools)) {
-    for (const agentId of tool.invokable_by) {
-      totalChecks++;
-      const agent = dsl.agents[agentId];
-      if (agent && agent.can_execute_tools.includes(toolId)) {
-        passedChecks++;
-      } else {
-        issues.push(`tool ${toolId} \u2192 agent ${agentId}`);
-      }
-    }
-  }
-  return {
-    id: "cross-reference-bidirectionality",
-    label: "Cross-reference bidirectionality",
-    score: passedChecks,
-    total: totalChecks,
-    percent: pct(passedChecks, totalChecks),
-    weight: 2,
-    recommendations: issues.length > 0 ? [`${issues.length} unreciprocated cross-references: ${issues.slice(0, 5).join(", ")}${issues.length > 5 ? `, ... (${issues.length - 5} more)` : ""}`] : []
-  };
-}
 function entityGuardrailCoverage(dsl) {
   const entitySections = [
     { name: "agents", entities: dsl.agents },
@@ -54943,7 +54907,6 @@ function score(dsl) {
     guardrailPolicyCoverage(dsl),
     workflowValidationIntegration(dsl),
     schemaCompleteness(dsl),
-    crossReferenceBidirectionality(dsl),
     guardrailScopeResolution(dsl),
     entityGuardrailCoverage(dsl)
   ];