agent-contracts 0.24.0 → 0.25.0

package/dist/cli.js

@@ -49690,6 +49690,7 @@ var PrerequisiteSchema = z.object({
 var AgentSchema = z.object({
   role_name: z.string(),
   purpose: z.string(),
+  own_artifacts: z.array(z.string()).default([]),
   can_read_artifacts: z.array(z.string()).default([]),
   can_write_artifacts: z.array(z.string()).default([]),
   can_execute_tools: z.array(z.string()).default([]),
@@ -49923,6 +49924,8 @@ var ExecutionStepSchema = z9.object({
   uses_tool: z9.string().optional(),
   produces_artifact: z9.string().optional(),
   reads_artifact: z9.string().optional(),
+  validates_artifact: z9.string().optional(),
+  validation_kind: z9.enum(["schema", "mechanical", "semantic", "approval", "provenance", "traceability", "fidelity"]).optional(),
   depends_on: z9.array(z9.string()).optional(),
   skip_condition: z9.string().optional(),
   wait_for_approval: z9.boolean().optional()
@@ -49990,6 +49993,8 @@ var ToolSchema = z12.object({
   input_artifacts: z12.array(z12.string()).default([]),
   output_artifacts: z12.array(z12.string()).default([]),
   invokable_by: z12.array(z12.string()).default([]),
+  cli_contract: z12.string().optional(),
+  artifact_bindings: z12.record(z12.string(), z12.string()).default({}),
   side_effects: z12.array(z12.string()).default([]),
   commands: z12.array(CommandSchema).default([]),
   guardrails: z12.array(z12.string()).optional()
@@ -50000,8 +50005,8 @@ 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(),
+  executor_type: z13.enum(["tool", "agent"]).optional(),
+  executor: z13.string().optional(),
   blocking: z13.boolean(),
   produces_evidence: z13.string().optional(),
   description: z13.string().optional()
@@ -52103,6 +52108,9 @@ function checkReferences(dsl) {
     }
   }
   for (const [id, agent] of Object.entries(dsl.agents)) {
+    for (const ref of agent.own_artifacts) {
+      checkExists(ref, artifactIds, "artifacts", `agents.${id}.own_artifacts`);
+    }
     for (const ref of agent.can_read_artifacts) {
       checkExists(ref, artifactIds, "artifacts", `agents.${id}.can_read_artifacts`);
     }
@@ -52158,7 +52166,7 @@ function checkReferences(dsl) {
     }
     for (const valId of art.required_validations) {
       const validation = dsl.validations[valId];
-      if (validation?.executor_type === "tool") {
+      if (validation?.executor_type === "tool" && validation.executor) {
         const tool = dsl.tools[validation.executor];
         if (tool && tool.invokable_by.length === 0) {
           diagnostics.push({
@@ -52176,12 +52184,15 @@ function checkReferences(dsl) {
         checkExists(ref, agentIds, "agents", `tools.${id}.invokable_by`);
       }
     }
+    for (const ref of Object.values(tool.artifact_bindings)) {
+      checkExists(ref, artifactIds, "artifacts", `tools.${id}.artifact_bindings`);
+    }
   }
   for (const [id, val] of Object.entries(dsl.validations)) {
     checkExists(val.target_artifact, artifactIds, "artifacts", `validations.${id}.target_artifact`);
-    if (val.executor_type === "tool") {
+    if (val.executor_type === "tool" && val.executor) {
       checkExists(val.executor, toolIds, "tools", `validations.${id}.executor`);
-    } else if (val.executor_type === "agent") {
+    } else if (val.executor_type === "agent" && val.executor) {
       checkExists(val.executor, agentIds, "agents", `validations.${id}.executor`);
     }
   }
@@ -52565,10 +52576,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}"`
           });
@@ -52576,12 +52587,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}"`
           });
@@ -52604,7 +52616,7 @@ var toolExecutionRule = {
       }
     }
     for (const [valId, val] of Object.entries(dsl.validations)) {
-      if (val.executor_type !== "tool") continue;
+      if (val.executor_type !== "tool" || !val.executor) continue;
       const hasExecutor = Object.values(dsl.agents).some(
         (a3) => a3.can_execute_tools.includes(val.executor)
       );
@@ -52697,10 +52709,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}"`
             });
@@ -53184,6 +53196,7 @@ var validationExecutorNoContextRule = {
   run(dsl) {
     const diagnostics = [];
     for (const [validationId, val] of Object.entries(dsl.validations)) {
+      if (!val.executor) continue;
       if (val.executor_type === "agent") {
         const agent = dsl.agents[val.executor];
         if (!agent) continue;
@@ -53211,6 +53224,40 @@ var validationExecutorNoContextRule = {
   }
 };
 
+// src/linter/rules/artifact-ownership-consistency.ts
+var artifactOwnershipConsistencyRule = {
+  id: "artifact-ownership-consistency",
+  description: "Ensure own_artifacts entries are included in can_read_artifacts and check deprecated owner field consistency",
+  run(dsl) {
+    const diagnostics = [];
+    for (const [agentId, agent] of Object.entries(dsl.agents)) {
+      for (const artId of agent.own_artifacts) {
+        if (!agent.can_read_artifacts.includes(artId)) {
+          diagnostics.push({
+            ruleId: "artifact-ownership-consistency",
+            severity: "warning",
+            path: `agents.${agentId}.own_artifacts`,
+            message: `Agent "${agentId}" owns artifact "${artId}" but does not include it in can_read_artifacts`
+          });
+        }
+      }
+    }
+    for (const [artId, art] of Object.entries(dsl.artifacts)) {
+      if (!art.owner) continue;
+      const ownerAgent = dsl.agents[art.owner];
+      if (ownerAgent && !ownerAgent.own_artifacts.includes(artId)) {
+        diagnostics.push({
+          ruleId: "artifact-ownership-consistency",
+          severity: "warning",
+          path: `artifacts.${artId}.owner`,
+          message: `Artifact "${artId}" has deprecated owner "${art.owner}" but agent does not list it in own_artifacts`
+        });
+      }
+    }
+    return diagnostics;
+  }
+};
+
 // src/linter/rules/extension-consumption.ts
 function isRecord4(v2) {
   return typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
@@ -53398,6 +53445,7 @@ var builtinRules = [
   entityNoGuardrailsRule,
   guardrailOrphanedRule,
   validationExecutorNoContextRule,
+  artifactOwnershipConsistencyRule,
   extensionDeclaredButUnusedRule,
   extensionScopeMismatchRule,
   extensionUndeclaredUsageRule
@@ -53867,9 +53915,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",
@@ -53888,8 +53936,8 @@ var ruleset = {
       }
     },
     "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",
@@ -54593,8 +54641,8 @@ function collectReferencedIds(workflow, dsl, relatedTasks) {
     } else if (step.type === "validation") {
       const val = dsl.validations[step.validation];
       if (val) {
-        if (val.executor_type === "agent") addAgent(val.executor);
-        else tools.add(val.executor);
+        if (val.executor && val.executor_type === "agent") addAgent(val.executor);
+        else if (val.executor) tools.add(val.executor);
         artifacts.add(val.target_artifact);
       }
     }
@@ -54970,9 +55018,9 @@ function collectPhaseOps(dsl, wfId) {
     } else if (step.type === "validation") {
       const val = dsl.validations[step.validation];
       if (val) {
-        if (val.executor_type === "agent") {
+        if (val.executor_type === "agent" && val.executor) {
           addOp(agentOps, val.executor, "validate");
-        } else {
+        } else if (val.executor) {
           addOp(toolOps, val.executor, "verification");
         }
         addOp(artifactOps, val.target_artifact, "V");