agent-contracts 0.23.2 → 0.24.0

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`);
+      }
     }
-    for (const ref of art.consumers) {
-      checkExists(ref, agentIds, "agents", `artifacts.${id}.consumers`);
+    if (art.editors.length > 0) {
+      for (const ref of art.editors) {
+        checkExists(ref, agentIds, "agents", `artifacts.${id}.editors`);
+      }
+    }
+    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)) {
@@ -51606,7 +51623,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 +51637,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 +52536,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 +52547,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 +52558,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",
@@ -52718,9 +52735,9 @@ 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
@@ -54181,6 +54198,12 @@ function expandOutputPath(pattern, context, entityId, entity) {
     }
   );
 }
+var CONTEXT_TYPE_PATTERN = new RegExp(
+  `\\{(${CONTEXT_TYPES.join("|")})\\.[^}]+\\}`
+);
+function hasUnresolvedPathVars(path) {
+  return CONTEXT_TYPE_PATTERN.test(path);
+}
 function buildEntityContext(dsl, context, entityId) {
   switch (context) {
     case "agent": {
@@ -54246,6 +54269,7 @@ async function renderFromConfig(dsl, renderTargets, options) {
         const output = compiled(ctx);
         const entity = section[entityId];
         const outputPath = expandOutputPath(target.output, target.context, entityId, entity);
+        if (hasUnresolvedPathVars(outputPath)) continue;
         if (target.skip_empty && isEffectivelyEmpty(output)) {
           await removeIfExists(outputPath);
           continue;
@@ -54296,6 +54320,7 @@ async function checkDriftFromConfig(dsl, renderTargets, options) {
         const expected = compiled(ctx);
         const entity = section[entityId];
         const outputPath = expandOutputPath(target.output, target.context, entityId, entity);
+        if (hasUnresolvedPathVars(outputPath)) continue;
         await checkExpectedVsExisting(expected, outputPath, target.skip_empty, diffs);
       }
     }
@@ -54791,60 +54816,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 },
@@ -54935,7 +54906,6 @@ function score(dsl) {
     guardrailPolicyCoverage(dsl),
     workflowValidationIntegration(dsl),
     schemaCompleteness(dsl),
-    crossReferenceBidirectionality(dsl),
     guardrailScopeResolution(dsl),
     entityGuardrailCoverage(dsl)
   ];
@@ -56294,10 +56264,9 @@ async function generateGuardrails(options) {
           const mergedCtx = { ...entityCtx, vars, paths, binding, resolved_checks: checkResult.resolved };
           const rendered = compiled(mergedCtx);
           const entity = section[entityId];
-          const resolvedOutput = resolveBindingRenderOutputPath(
-            expandOutputPath(renderTarget.output, context, entityId, entity),
-            paths
-          );
+          const expandedOutput = expandOutputPath(renderTarget.output, context, entityId, entity);
+          if (hasUnresolvedPathVars(expandedOutput)) continue;
+          const resolvedOutput = resolveBindingRenderOutputPath(expandedOutput, paths);
           const outputPath = resolve6(config.configDir, resolvedOutput);
           if (shouldSkipEmpty && rendered.trim().length === 0) {
             if (!dryRun) {