agent-contracts 0.24.0 → 0.25.0

package/dist/index.d.ts

@@ -46,6 +46,7 @@ type Prerequisite = z.infer<typeof PrerequisiteSchema>;
 declare const AgentSchema: z.ZodObject<{
     role_name: z.ZodString;
     purpose: z.ZodString;
+    own_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
     can_read_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
     can_write_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
     can_execute_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -401,6 +402,7 @@ declare const DslSchema: z.ZodObject<{
     agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         role_name: z.ZodString;
         purpose: z.ZodString;
+        own_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
         can_read_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
         can_write_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
         can_execute_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -476,6 +478,16 @@ declare const DslSchema: z.ZodObject<{
             uses_tool: z.ZodOptional<z.ZodString>;
             produces_artifact: z.ZodOptional<z.ZodString>;
             reads_artifact: z.ZodOptional<z.ZodString>;
+            validates_artifact: z.ZodOptional<z.ZodString>;
+            validation_kind: z.ZodOptional<z.ZodEnum<{
+                schema: "schema";
+                mechanical: "mechanical";
+                semantic: "semantic";
+                approval: "approval";
+                provenance: "provenance";
+                traceability: "traceability";
+                fidelity: "fidelity";
+            }>>;
             depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
             skip_condition: z.ZodOptional<z.ZodString>;
             wait_for_approval: z.ZodOptional<z.ZodBoolean>;
@@ -553,6 +565,8 @@ declare const DslSchema: z.ZodObject<{
         input_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
         output_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
         invokable_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        cli_contract: z.ZodOptional<z.ZodString>;
+        artifact_bindings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
         side_effects: z.ZodDefault<z.ZodArray<z.ZodString>>;
         commands: z.ZodDefault<z.ZodArray<z.ZodObject<{
             command: z.ZodString;
@@ -574,11 +588,11 @@ declare const DslSchema: z.ZodObject<{
             traceability: "traceability";
             fidelity: "fidelity";
         }>;
-        executor_type: z.ZodEnum<{
+        executor_type: z.ZodOptional<z.ZodEnum<{
             agent: "agent";
             tool: "tool";
-        }>;
-        executor: z.ZodString;
+        }>>;
+        executor: z.ZodOptional<z.ZodString>;
         blocking: z.ZodBoolean;
         produces_evidence: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
@@ -991,6 +1005,16 @@ declare const ExecutionStepSchema: z.ZodObject<{
     uses_tool: z.ZodOptional<z.ZodString>;
     produces_artifact: z.ZodOptional<z.ZodString>;
     reads_artifact: z.ZodOptional<z.ZodString>;
+    validates_artifact: z.ZodOptional<z.ZodString>;
+    validation_kind: z.ZodOptional<z.ZodEnum<{
+        schema: "schema";
+        mechanical: "mechanical";
+        semantic: "semantic";
+        approval: "approval";
+        provenance: "provenance";
+        traceability: "traceability";
+        fidelity: "fidelity";
+    }>>;
     depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
     skip_condition: z.ZodOptional<z.ZodString>;
     wait_for_approval: z.ZodOptional<z.ZodBoolean>;
@@ -1016,6 +1040,16 @@ declare const TaskSchema: z.ZodObject<{
         uses_tool: z.ZodOptional<z.ZodString>;
         produces_artifact: z.ZodOptional<z.ZodString>;
         reads_artifact: z.ZodOptional<z.ZodString>;
+        validates_artifact: z.ZodOptional<z.ZodString>;
+        validation_kind: z.ZodOptional<z.ZodEnum<{
+            schema: "schema";
+            mechanical: "mechanical";
+            semantic: "semantic";
+            approval: "approval";
+            provenance: "provenance";
+            traceability: "traceability";
+            fidelity: "fidelity";
+        }>>;
         depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
         skip_condition: z.ZodOptional<z.ZodString>;
         wait_for_approval: z.ZodOptional<z.ZodBoolean>;
@@ -1072,6 +1106,8 @@ declare const ToolSchema: z.ZodObject<{
     input_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
     output_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
     invokable_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    cli_contract: z.ZodOptional<z.ZodString>;
+    artifact_bindings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     side_effects: z.ZodDefault<z.ZodArray<z.ZodString>>;
     commands: z.ZodDefault<z.ZodArray<z.ZodObject<{
         command: z.ZodString;
@@ -1095,11 +1131,11 @@ declare const ValidationSchema: z.ZodObject<{
         traceability: "traceability";
         fidelity: "fidelity";
     }>;
-    executor_type: z.ZodEnum<{
+    executor_type: z.ZodOptional<z.ZodEnum<{
         agent: "agent";
         tool: "tool";
-    }>;
-    executor: z.ZodString;
+    }>>;
+    executor: z.ZodOptional<z.ZodString>;
     blocking: z.ZodBoolean;
     produces_evidence: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
@@ -1519,7 +1555,7 @@ interface EntityValidationEntry {
     validation_id: string;
     kind: string;
     target_artifact: string;
-    executor_type: string;
+    executor_type?: string;
     blocking: boolean;
     produces_evidence?: string;
 }

package/dist/index.js

@@ -48919,6 +48919,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([]),
@@ -49152,6 +49153,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()
@@ -49219,6 +49222,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()
@@ -49229,8 +49234,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()
@@ -50959,6 +50964,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`);
     }
@@ -51014,7 +51022,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({
@@ -51032,12 +51040,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`);
     }
   }
@@ -51421,10 +51432,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}"`
           });
@@ -51432,12 +51443,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}"`
           });
@@ -51460,7 +51472,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)
       );
@@ -51553,10 +51565,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}"`
             });
@@ -52040,6 +52052,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;
@@ -52067,6 +52080,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);
@@ -52254,6 +52301,7 @@ var builtinRules = [
   entityNoGuardrailsRule,
   guardrailOrphanedRule,
   validationExecutorNoContextRule,
+  artifactOwnershipConsistencyRule,
   extensionDeclaredButUnusedRule,
   extensionScopeMismatchRule,
   extensionUndeclaredUsageRule
@@ -52723,9 +52771,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",
@@ -52744,8 +52792,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",
@@ -53464,8 +53512,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);
       }
     }
@@ -53841,9 +53889,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");