archctx 0.11.3 → 0.11.4

package/assets/catalog.yaml

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "archcontext.practice-catalog-manifest/v1",
   "catalogVersion": "2026.06.0",
-  "productVersion": "0.11.3",
+  "productVersion": "0.11.4",
   "generatedAt": "1970-01-01T00:00:00.000Z",
   "entries": [
     {
@@ -389,5 +389,5 @@
     "structurizr.dsl",
     "twelve-factor"
   ],
-  "catalogDigest": "sha256:642dc69ef47da32c8af19354d4530583fcb970e54b5539cbfbfbae0ee98786f9"
+  "catalogDigest": "sha256:eccb96c1058b021be25a7efc44a0298077852d44bd6cb04f94e76d20ace812ce"
 }

package/bin/archctx.mjs

@@ -4125,7 +4125,7 @@ function compareVersionTriples(left, right) {
   }
   return 0;
 }
-var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.11.3", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.4.3", ARCHCONTEXT_NODE_RANGE = ">=22.22 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v2", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-07-11.explorer-view-v2";
+var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.11.4", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.4.3", ARCHCONTEXT_NODE_RANGE = ">=22.22 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v2", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-07-11.explorer-view-v2";
 
 // packages/contracts/src/refactor.ts
 function refactorNamespaceIssues(value, label = "product.id") {
@@ -22360,6 +22360,7 @@ function evaluateDependencyConstraints(input) {
   const nodeById = new Map(input.nodes.map((node) => [node.id, node]));
   const reasonCodes = new Set(certification.reasonCodes);
   const violations = new Map;
+  const layerEdgeCounts = new Map;
   for (const edge of edges) {
     if (edge.to === null)
       continue;
@@ -22367,12 +22368,25 @@ function evaluateDependencyConstraints(input) {
     const toOwners = ownerChains(edge.to);
     for (const constraint of constraints) {
       const key = JSON.stringify([constraint.id, edge.from, edge.to]);
-      if (violations.has(key))
-        continue;
       const rule = constraint.rule;
       if (rule.type === "layer-direction") {
         const layer = (owner) => nodeById.get(owner.owner)?.layer;
         const classified = (owner) => typeof layer(owner) === "string" && rule.layers.includes(layer(owner));
+        const soleLayer = (owners) => {
+          const layers = new Set(owners.map(layer));
+          const [only] = layers;
+          return layers.size === 1 && only !== undefined && rule.layers.includes(only) ? only : undefined;
+        };
+        const fromSole = soleLayer(fromOwners);
+        const toSole = soleLayer(toOwners);
+        if (fromSole !== undefined && toSole !== undefined) {
+          const rowKey = JSON.stringify([constraint.id, fromSole, toSole]);
+          const row = layerEdgeCounts.get(rowKey);
+          if (row)
+            row.imports += 1;
+          else
+            layerEdgeCounts.set(rowKey, { constraintId: constraint.id, fromLayer: fromSole, toLayer: toSole, imports: 1 });
+        }
         const hasLayer = [...fromOwners, ...toOwners].some((owner) => layer(owner) !== undefined);
         if (hasLayer && (fromOwners.length === 0 || toOwners.length === 0 || [...fromOwners, ...toOwners].some((owner) => !classified(owner))))
           reasonCodes.add("layer-endpoint-unclassified");
@@ -22389,6 +22403,8 @@ function evaluateDependencyConstraints(input) {
           }
         continue;
       }
+      if (violations.has(key))
+        continue;
       const from = fromOwners.find((owner) => meets(owner.chain, constraint.scope.nodes) && !meets(owner.chain, rule.targets));
       const to = toOwners.find((owner) => meets(owner.chain, rule.targets));
       if (!from || !to)
@@ -22410,15 +22426,19 @@ function evaluateDependencyConstraints(input) {
   if (input.workspacePackagesResolved === false)
     reasonCodes.add("workspace-resolution-failed");
   const sortedViolations = [...violations.values()].sort((left, right) => compare3(left.constraintId, right.constraintId) || compare3(left.fromPath, right.fromPath) || compare3(left.toPath, right.toPath));
+  const status = sortedViolations.length > 0 ? "violated" : reasonCodes.size > 0 ? "undetermined" : "pass";
+  const layerEdgesObserved = constraints.some((constraint) => constraint.rule.type === "layer-direction") && (status === "pass" || status === "violated") && certification.coverage === "complete";
+  const layerEdges = [...layerEdgeCounts.values()].sort((left, right) => compare3(left.constraintId, right.constraintId) || compare3(left.fromLayer, right.fromLayer) || compare3(left.toLayer, right.toLayer));
   return {
     schemaVersion: "archcontext.dependency-constraint-evaluation/v1",
-    status: sortedViolations.length > 0 ? "violated" : reasonCodes.size > 0 ? "undetermined" : "pass",
+    status,
     coverage: certification.coverage,
     reasonCodes: [...reasonCodes].sort(),
     constraintIds: constraints.map((constraint) => constraint.id),
     importEdgeCount: edges.length,
     unresolvedImports,
-    violations: sortedViolations
+    violations: sortedViolations,
+    ...layerEdgesObserved ? { layerEdges } : {}
   };
 }
 function measureCapabilityDependencies(input) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archctx",
-  "version": "0.11.3",
+  "version": "0.11.4",
   "description": "Local architecture context CLI for agentic coding workflows.",
   "private": false,
   "type": "module",

package/schemas/runtime/dependency-constraint-evaluation.schema.json

@@ -0,0 +1,207 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://archcontext.dev/schemas/runtime/dependency-constraint-evaluation.schema.json",
+  "title": "DependencyConstraintEvaluationV1",
+  "description": "The data of `archctx constraints check`: a read-only evaluation of the model's dependency constraints against observed import edges. `warnings` is added by the constraints-check command from the declaration reader, so it is not part of the evaluator's own type. Without code facts that attest to the measured tree, the evaluation still answers, but `coverage` is not `complete` and the import observations are dropped rather than reported as facts about some other tree.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "status",
+    "coverage",
+    "reasonCodes",
+    "constraintIds",
+    "importEdgeCount",
+    "unresolvedImports",
+    "violations",
+    "warnings"
+  ],
+  "properties": {
+    "schemaVersion": {
+      "const": "archcontext.dependency-constraint-evaluation/v1"
+    },
+    "status": {
+      "enum": [
+        "not-applicable",
+        "pass",
+        "undetermined",
+        "violated"
+      ]
+    },
+    "coverage": {
+      "enum": [
+        "complete",
+        "partial",
+        "unknown"
+      ],
+      "description": "`complete` only when an index attested to the evaluated worktree and was not truncated."
+    },
+    "reasonCodes": {
+      "type": "array",
+      "uniqueItems": true,
+      "description": "Why a result is not a complete observation, sorted.",
+      "items": {
+        "enum": [
+          "code-facts-import-limit",
+          "code-facts-stale",
+          "code-facts-truncated",
+          "code-facts-unavailable",
+          "unresolved-import",
+          "layer-endpoint-unclassified",
+          "workspace-resolution-failed"
+        ]
+      }
+    },
+    "constraintIds": {
+      "type": "array",
+      "description": "The constraints this evaluation covered, in declaration order.",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      }
+    },
+    "importEdgeCount": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Import observations the evaluation read; zero when the index did not attest to this tree."
+    },
+    "unresolvedImports": {
+      "type": "array",
+      "description": "Repository-local specifiers from constrained files that resolved to no file.",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "from",
+          "specifier"
+        ],
+        "properties": {
+          "from": {
+            "type": "string",
+            "minLength": 1
+          },
+          "specifier": {
+            "type": "string",
+            "minLength": 1
+          }
+        }
+      }
+    },
+    "violations": {
+      "type": "array",
+      "description": "One record per (constraint, from path, to path), sorted by those keys.",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "constraintId",
+          "fromPath",
+          "toPath",
+          "fromNode",
+          "toNode",
+          "severity"
+        ],
+        "properties": {
+          "constraintId": {
+            "type": "string",
+            "minLength": 1
+          },
+          "fromPath": {
+            "type": "string",
+            "minLength": 1
+          },
+          "toPath": {
+            "type": "string",
+            "minLength": 1
+          },
+          "fromNode": {
+            "type": "string",
+            "minLength": 1
+          },
+          "toNode": {
+            "type": "string",
+            "minLength": 1
+          },
+          "fromLayer": {
+            "type": "string",
+            "minLength": 1
+          },
+          "toLayer": {
+            "type": "string",
+            "minLength": 1
+          },
+          "severity": {
+            "enum": [
+              "error",
+              "warning"
+            ]
+          }
+        }
+      }
+    },
+    "layerEdges": {
+      "type": "array",
+      "description": "Resolved imports between two layers of one `layer-direction` constraint. An import counts only when every owner of each endpoint carries one shared layer listed in the rule. Present only with a `layer-direction` constraint, `status` `pass` or `violated`, and `coverage` `complete`; otherwise absent. When present it may be an empty list, and it is sorted by `(constraintId, fromLayer, toLayer)`.",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "constraintId",
+          "fromLayer",
+          "toLayer",
+          "imports"
+        ],
+        "properties": {
+          "constraintId": {
+            "type": "string",
+            "minLength": 1
+          },
+          "fromLayer": {
+            "type": "string",
+            "minLength": 1
+          },
+          "toLayer": {
+            "type": "string",
+            "minLength": 1
+          },
+          "imports": {
+            "type": "integer",
+            "minimum": 1,
+            "description": "Import edges, so two specifiers from one file to the same target count twice."
+          }
+        }
+      }
+    },
+    "warnings": {
+      "type": "array",
+      "description": "Declaration-reader warnings, such as an unsupported rule. Every unevaluated constraint type produces one, because a validated constraint is not proof that its rule was evaluated.",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      }
+    }
+  },
+  "allOf": [
+    {
+      "description": "The layer edges are an observation, so they exist only for a settled verdict over complete coverage.",
+      "if": {
+        "required": [
+          "layerEdges"
+        ]
+      },
+      "then": {
+        "properties": {
+          "status": {
+            "enum": [
+              "pass",
+              "violated"
+            ]
+          },
+          "coverage": {
+            "const": "complete"
+          }
+        }
+      }
+    }
+  ]
+}