@principal-ai/principal-view-cli 0.3.8 → 0.4.1

package/dist/index.cjs

@@ -8971,9 +8971,9 @@ var require_out4 = __commonJS({
   }
 });
 
-// node_modules/globby/node_modules/ignore/index.js
+// node_modules/ignore/index.js
 var require_ignore = __commonJS({
-  "node_modules/globby/node_modules/ignore/index.js"(exports2, module2) {
+  "node_modules/ignore/index.js"(exports2, module2) {
     function makeArray(subject) {
       return Array.isArray(subject) ? subject : [subject];
     }
@@ -241190,19 +241190,6 @@ function getNestedValue(obj, path4) {
   }
   return current;
 }
-function setNestedValue(obj, path4, value) {
-  const keys = path4.split(".");
-  let current = obj;
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (current[key] === void 0 || typeof current[key] !== "object") {
-      current[key] = {};
-    }
-    current = current[key];
-  }
-  const lastKey = keys[keys.length - 1];
-  current[lastKey] = value;
-}
 function computeAggregates(events) {
   const aggregates = {
     // Event counts
@@ -241216,15 +241203,12 @@ function computeAggregates(events) {
     "warnLogs.count": events.filter((e) => e.type === "log" && (e.severityNumber ?? 0) >= 13 && (e.severityNumber ?? 0) <= 16).length,
     "debugLogs.count": events.filter((e) => e.type === "log" && (e.severityNumber ?? 0) >= 5 && (e.severityNumber ?? 0) <= 8).length
   };
-  for (const event of events) {
+  const summaryEventPatterns = [".complete", ".summary", ".error", ".started"];
+  const summaryEvents = events.filter((e) => summaryEventPatterns.some((pattern) => e.name.endsWith(pattern)));
+  for (const event of summaryEvents) {
     if (event.attributes) {
       for (const [key, value] of Object.entries(event.attributes)) {
-        if (getNestedValue(aggregates, key) === void 0) {
-          setNestedValue(aggregates, key, value);
-          if (key.includes(".")) {
-            aggregates[key] = value;
-          }
-        }
+        aggregates[key] = value;
       }
     }
   }
@@ -241233,6 +241217,21 @@ function computeAggregates(events) {
 
 // node_modules/@principal-ai/principal-view-core/dist/narrative/template-parser.js
 var import_handlebars = __toESM(require_lib());
+import_handlebars.default.registerHelper("eq", (a, b) => a === b);
+import_handlebars.default.registerHelper("ne", (a, b) => a !== b);
+import_handlebars.default.registerHelper("lt", (a, b) => a < b);
+import_handlebars.default.registerHelper("gt", (a, b) => a > b);
+import_handlebars.default.registerHelper("lte", (a, b) => a <= b);
+import_handlebars.default.registerHelper("gte", (a, b) => a >= b);
+import_handlebars.default.registerHelper("and", (...args) => {
+  const values = args.slice(0, -1);
+  return values.every(Boolean);
+});
+import_handlebars.default.registerHelper("or", (...args) => {
+  const values = args.slice(0, -1);
+  return values.some(Boolean);
+});
+import_handlebars.default.registerHelper("not", (a) => !a);
 function parseTemplate(template, context) {
   try {
     const handlebarTemplate = import_handlebars.default.compile(template, { noEscape: true });
@@ -241319,7 +241318,25 @@ function renderSpanTree(tree, scenario, context, formatting2) {
   const parts = [];
   for (const node of tree) {
     const indent = (formatting2.indentPerLevel || "  ").repeat(node.depth);
-    const eventContext = { ...context, ...node.span.attributes, span: node.span };
+    const eventContext = { ...context };
+    if (node.span.attributes) {
+      for (const [key, value] of Object.entries(node.span.attributes)) {
+        if (key.includes(".")) {
+          const parts2 = key.split(".");
+          let current = eventContext;
+          for (let i = 0; i < parts2.length - 1; i++) {
+            if (!current[parts2[i]] || typeof current[parts2[i]] !== "object") {
+              current[parts2[i]] = {};
+            }
+            current = current[parts2[i]];
+          }
+          current[parts2[parts2.length - 1]] = value;
+        } else {
+          eventContext[key] = value;
+        }
+      }
+    }
+    eventContext.span = node.span;
     if (scenario.template.span) {
       const spanText = parseTemplate(scenario.template.span, eventContext);
       parts.push(indent + spanText);
@@ -241353,7 +241370,24 @@ function renderTimeline(events, scenario, context, formatting2) {
     return aTime - bTime;
   });
   for (const event of sorted) {
-    const eventContext = { ...context, ...event.attributes };
+    const eventContext = { ...context };
+    if (event.attributes) {
+      for (const [key, value] of Object.entries(event.attributes)) {
+        if (key.includes(".")) {
+          const parts2 = key.split(".");
+          let current = eventContext;
+          for (let i = 0; i < parts2.length - 1; i++) {
+            if (!current[parts2[i]] || typeof current[parts2[i]] !== "object") {
+              current[parts2[i]] = {};
+            }
+            current = current[parts2[i]];
+          }
+          current[parts2[parts2.length - 1]] = value;
+        } else {
+          eventContext[key] = value;
+        }
+      }
+    }
     let eventText;
     if (event.type === "log") {
       eventText = renderLog(event, scenario, { ...eventContext, log: event }, formatting2);
@@ -241673,8 +241707,8 @@ var NarrativeValidator = class {
     }
     const canvasEvents = /* @__PURE__ */ new Set();
     for (const node of canvas.nodes) {
-      if (node.pv?.event?.name) {
-        canvasEvents.add(node.pv.event.name);
+      if (node.pv?.event && typeof node.pv.event === "string") {
+        canvasEvents.add(node.pv.event);
       }
     }
     const narrativeEvents = /* @__PURE__ */ new Set();
@@ -241688,7 +241722,9 @@ var NarrativeValidator = class {
       }
       if (scenario.template?.events) {
         for (const eventName of Object.keys(scenario.template.events)) {
-          narrativeEvents.add(eventName);
+          if (!eventName.includes("*")) {
+            narrativeEvents.add(eventName);
+          }
         }
       }
     }
@@ -242104,7 +242140,7 @@ var NarrativeValidator = class {
           path: path4,
           message: `Incomplete conditional expression: ${expr}`,
           impact: "Template will fail to render",
-          suggestion: 'Conditional format: {condition ? "true" : "false"}',
+          suggestion: "Use Handlebars syntax: {{#if condition}}true{{else}}false{{/if}}",
           fixable: false
         });
       }
@@ -242112,12 +242148,137 @@ var NarrativeValidator = class {
     return violations;
   }
   /**
-   * Check attribute references (warning level)
+   * Check attribute references against execution data
+   *
+   * Validates that:
+   * - Attributes referenced in templates exist in execution data
+   * - Object attributes are accessed via properties (not used directly)
+   * - Attribute names are correct (catches typos)
    */
-  checkAttributeReferences(_context) {
+  checkAttributeReferences(context) {
     const violations = [];
+    const { narrative, narrativePath, executionData } = context;
+    if (!executionData) {
+      return violations;
+    }
+    const { aggregates, eventAttributes } = executionData;
+    for (const scenario of narrative.scenarios) {
+      const scenarioPath = `scenarios[${scenario.id}]`;
+      if (scenario.template.introduction) {
+        const attrs = this.extractAttributeReferences(scenario.template.introduction);
+        violations.push(...this.validateAttributes(
+          attrs,
+          aggregates,
+          null,
+          // introduction doesn't have specific event context
+          narrativePath,
+          `${scenarioPath}.template.introduction`
+        ));
+      }
+      if (scenario.template.events) {
+        for (const [eventName, eventTemplate] of Object.entries(scenario.template.events)) {
+          const attrs = this.extractAttributeReferences(eventTemplate);
+          const eventAttrs = eventAttributes.get(eventName);
+          violations.push(...this.validateAttributes(attrs, aggregates, eventAttrs || null, narrativePath, `${scenarioPath}.template.events.${eventName}`, eventName));
+        }
+      }
+      if (scenario.template.summary) {
+        const attrs = this.extractAttributeReferences(scenario.template.summary);
+        violations.push(...this.validateAttributes(
+          attrs,
+          aggregates,
+          null,
+          // summary uses global aggregates
+          narrativePath,
+          `${scenarioPath}.template.summary`
+        ));
+      }
+    }
     return violations;
   }
+  /**
+   * Validate a list of attribute references against available data
+   *
+   * @param attributes - Attribute paths to validate
+   * @param aggregates - Global aggregate attributes
+   * @param eventAttributes - Event-specific attributes (if validating event template)
+   * @param file - File path for violation reporting
+   * @param path - JSON path for violation reporting
+   * @param eventName - Event name (if validating event template)
+   * @returns Array of violations found
+   */
+  validateAttributes(attributes, aggregates, eventAttributes, file, path4, eventName) {
+    const violations = [];
+    for (const attr of attributes) {
+      const globalValue = aggregates[attr];
+      const eventValue = eventAttributes?.[attr];
+      if (globalValue === void 0 && eventValue === void 0) {
+        const allKeys = [
+          ...Object.keys(aggregates),
+          ...eventAttributes ? Object.keys(eventAttributes) : []
+        ];
+        const similar = this.findSimilarAttributes(attr, allKeys);
+        violations.push({
+          ruleId: "narrative-attribute-undefined",
+          severity: "warn",
+          file,
+          path: path4,
+          message: eventName ? `Attribute "{{${attr}}}" not found in event "${eventName}" or global aggregates` : `Attribute "{{${attr}}}" not found in execution data`,
+          impact: 'Template will render as empty or "undefined"',
+          suggestion: similar.length > 0 ? `Did you mean: ${similar.join(", ")}?` : void 0,
+          fixable: false
+        });
+        continue;
+      }
+      const value = eventValue !== void 0 ? eventValue : globalValue;
+      if (this.isObjectType(value)) {
+        const objectKeys = Object.keys(value);
+        const suggestions = objectKeys.slice(0, 3).map((k) => `{{${attr}.${k}}}`);
+        violations.push({
+          ruleId: "narrative-attribute-object",
+          severity: "warn",
+          file,
+          path: path4,
+          message: `Attribute "{{${attr}}}" is an object and will render as "[object Object]"`,
+          impact: 'Template will show "[object Object]" instead of useful data',
+          suggestion: `Access a property instead: ${suggestions.join(", ")}`,
+          fixable: false
+        });
+      }
+    }
+    return violations;
+  }
+  /**
+   * Find similar attribute names for helpful suggestions
+   *
+   * Uses simple string similarity (Levenshtein-like) to find typos
+   *
+   * @param target - The attribute being searched for
+   * @param available - Available attribute names
+   * @returns Array of similar attribute names (max 3)
+   */
+  findSimilarAttributes(target, available) {
+    const similar = [];
+    for (const attr of available) {
+      if (attr.startsWith(target) || target.startsWith(attr)) {
+        similar.push({ attr, score: 10 });
+        continue;
+      }
+      if (attr.includes(target) || target.includes(attr)) {
+        similar.push({ attr, score: 5 });
+        continue;
+      }
+      const targetParts = target.split(".");
+      const attrParts = attr.split(".");
+      if (targetParts.length === attrParts.length) {
+        const matchingParts = targetParts.filter((p, i) => p === attrParts[i]).length;
+        if (matchingParts > 0) {
+          similar.push({ attr, score: matchingParts });
+        }
+      }
+    }
+    return similar.sort((a, b) => b.score - a.score).slice(0, 3).map((s) => s.attr);
+  }
   /**
    * Check formatting options
    */
@@ -242219,6 +242380,71 @@ var NarrativeValidator = class {
     }
     return match[1];
   }
+  /**
+   * Extract attribute references from Handlebars template
+   *
+   * Parses template strings like:
+   * - "{{source}}" -> ["source"]
+   * - "{{source.url}}" -> ["source.url"]
+   * - "{{#if options.global}}" -> ["options.global"]
+   * - "{{#if (eq install.mode 'symlink')}}" -> ["install.mode"]
+   *
+   * @param template - Handlebars template string
+   * @returns Array of attribute paths referenced in the template
+   */
+  extractAttributeReferences(template) {
+    const attributes = /* @__PURE__ */ new Set();
+    const expressionPattern = /\{\{([^}]+)\}\}/g;
+    let match;
+    while ((match = expressionPattern.exec(template)) !== null) {
+      const expression = match[1].trim();
+      if (expression.startsWith("/")) {
+        continue;
+      }
+      if (expression.startsWith("#")) {
+        const helperMatch = expression.match(/^#\w+\s+(.+)$/);
+        if (helperMatch) {
+          this.extractAttributesFromExpression(helperMatch[1], attributes);
+        }
+        continue;
+      }
+      this.extractAttributesFromExpression(expression, attributes);
+    }
+    return Array.from(attributes);
+  }
+  /**
+   * Extract attribute references from a single Handlebars expression
+   *
+   * Handles:
+   * - Simple references: source.url
+   * - Helper calls: (eq install.mode 'symlink')
+   * - Nested expressions
+   *
+   * @param expression - The expression to parse
+   * @param attributes - Set to add found attributes to
+   */
+  extractAttributesFromExpression(expression, attributes) {
+    const cleaned = expression.replace(/^\(|\)$/g, "").trim();
+    const parts = cleaned.split(/\s+/);
+    for (const part of parts) {
+      if (part.match(/^(if|unless|each|with|eq|ne|lt|gt|lte|gte|and|or|not)$/) || part.match(/^['"].*['"]$/) || part.match(/^\d+$/) || part.match(/^(true|false|null|undefined)$/)) {
+        continue;
+      }
+      const cleanPart = part.replace(/['"()]/g, "");
+      if (cleanPart && cleanPart.match(/^[a-zA-Z_][a-zA-Z0-9_.]*$/)) {
+        attributes.add(cleanPart);
+      }
+    }
+  }
+  /**
+   * Check if an attribute is an object type
+   *
+   * @param value - The attribute value to check
+   * @returns true if value is a plain object (not array, not null)
+   */
+  isObjectType(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+  }
 };
 function createNarrativeValidator() {
   return new NarrativeValidator();
@@ -247413,13 +247639,18 @@ ${source_default.dim("\u2502")}       ${source_default.yellow('"type"')}: "text"
 ${source_default.dim("\u2502")}       ${source_default.yellow('"text"')}: "# Event Name", ${source_default.dim("// Markdown description")}     ${source_default.dim("\u2502")}
 ${source_default.dim("\u2502")}       ${source_default.yellow('"x"')}: 0, ${source_default.yellow('"y"')}: 0, ${source_default.yellow('"width"')}: 200, ${source_default.yellow('"height"')}: 100,                   ${source_default.dim("\u2502")}
 ${source_default.dim("\u2502")}       ${source_default.green('"pv"')}: {                                                        ${source_default.dim("\u2502")}
-${source_default.dim("\u2502")}         ${source_default.cyan('"otelEvent"')}: {          ${source_default.dim("// OTEL event definition")}    ${source_default.dim("\u2502")}
-${source_default.dim("\u2502")}           ${source_default.yellow('"name"')}: "feature.event.name",                          ${source_default.dim("\u2502")}
-${source_default.dim("\u2502")}           ${source_default.cyan('"attributes"')}: {       ${source_default.dim("// Required & optional attrs")} ${source_default.dim("\u2502")}
-${source_default.dim("\u2502")}             ${source_default.green('"required"')}: ["attr.name", ...],                     ${source_default.dim("\u2502")}
-${source_default.dim("\u2502")}             ${source_default.green('"optional"')}: ["attr.name", ...]                      ${source_default.dim("\u2502")}
-${source_default.dim("\u2502")}           }                                                            ${source_default.dim("\u2502")}
-${source_default.dim("\u2502")}         }                                                              ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}         ${source_default.cyan('"event"')}: "feature.event.name",  ${source_default.dim("// Event name")}          ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}         ${source_default.cyan('"sources"')}: ["src/file.ts"],     ${source_default.dim("// Source files")}        ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}         ${source_default.cyan('"otel"')}: {                       ${source_default.dim("// OTEL metadata")}       ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}           ${source_default.yellow('"kind"')}: "event",                                       ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}           ${source_default.yellow('"category"')}: "lifecycle"                               ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}         },                                                           ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}         ${source_default.cyan('"dataSchema"')}: {                 ${source_default.dim("// Attribute definitions")} ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}           ${source_default.yellow('"attr.name"')}: {                                         ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}             ${source_default.green('"type"')}: "string",                                    ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}             ${source_default.green('"required"')}: true                                     ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}           }                                                          ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}         }                                                            ${source_default.dim("\u2502")}
 ${source_default.dim("\u2502")}       }                                                                ${source_default.dim("\u2502")}
 ${source_default.dim("\u2502")}     }                                                                  ${source_default.dim("\u2502")}
 ${source_default.dim("\u2502")}   ],                                                                   ${source_default.dim("\u2502")}
@@ -247526,12 +247757,26 @@ ${source_default.cyan("2. Standard scenario set:")}
    - ${source_default.yellow("Failure")} (priority 2): Feature encountered error
    - ${source_default.dim("Fallback")} (priority 999): Generic execution captured
 
-${source_default.cyan("3. Template interpolation:")}
-   Use {{path.to.value}} to reference event attributes
-   Examples:
-   - {{record.count}}
-   - {{error.message}}
-   - {{result.invalidCount}}
+${source_default.cyan("3. Template syntax (Handlebars):")}
+   Templates use Handlebars syntax for dynamic content:
+
+   ${source_default.bold("Variables:")}
+   - {{variable}}           Simple variable
+   - {{result.count}}       Nested property
+   - {{error.message}}      Deeply nested
+
+   ${source_default.bold("Conditionals:")}
+   - {{#if condition}}...{{/if}}                    If block
+   - {{#if condition}}...{{else}}...{{/if}}         If-else
+   - {{#if (eq status "ok")}}\u2705{{else}}\u274C{{/if}}    Comparison
+
+   ${source_default.bold("Loops:")}
+   - {{#each items}}{{this}}{{/each}}               Iterate array
+   - {{#each items}}{{@index}}: {{this}}{{/each}}   With index
+
+   ${source_default.bold("Comparison helpers:")}
+   - eq, ne, lt, gt, lte, gte, and, or, not
+   - Example: {{#if (gt count 10)}}Many{{/if}}
 
 ${source_default.cyan("4. Template style:")}
    - Clear, concise summary line
@@ -247657,11 +247902,20 @@ ${source_default.yellow(".principal-views/data-validator.otel.canvas")}
       "text": "# validation.started\\n\\nEmitted when validation begins",
       "x": 0, "y": 0, "width": 200, "height": 100,
       "pv": {
-        "otelEvent": {
-          "name": "validation.started",
-          "attributes": {
-            "required": ["input.recordCount"],
-            "optional": ["input.source"]
+        "event": "validation.started",
+        "sources": ["src/validator.ts"],
+        "otel": {
+          "kind": "event",
+          "category": "lifecycle"
+        },
+        "dataSchema": {
+          "input.recordCount": {
+            "type": "number",
+            "required": true
+          },
+          "input.source": {
+            "type": "string",
+            "required": false
           }
         }
       }
@@ -247672,11 +247926,24 @@ ${source_default.yellow(".principal-views/data-validator.otel.canvas")}
       "text": "# validation.complete\\n\\nEmitted when validation succeeds",
       "x": 250, "y": 0, "width": 200, "height": 100,
       "pv": {
-        "otelEvent": {
-          "name": "validation.complete",
-          "attributes": {
-            "required": ["result.validCount", "result.invalidCount"],
-            "optional": ["duration.ms"]
+        "event": "validation.complete",
+        "sources": ["src/validator.ts"],
+        "otel": {
+          "kind": "event",
+          "category": "lifecycle"
+        },
+        "dataSchema": {
+          "result.validCount": {
+            "type": "number",
+            "required": true
+          },
+          "result.invalidCount": {
+            "type": "number",
+            "required": true
+          },
+          "duration.ms": {
+            "type": "number",
+            "required": false
           }
         }
       }
@@ -247687,11 +247954,24 @@ ${source_default.yellow(".principal-views/data-validator.otel.canvas")}
       "text": "# validation.error\\n\\nEmitted when validation fails",
       "x": 500, "y": 0, "width": 200, "height": 100,
       "pv": {
-        "otelEvent": {
-          "name": "validation.error",
-          "attributes": {
-            "required": ["error.type", "error.message"],
-            "optional": ["error.stage"]
+        "event": "validation.error",
+        "sources": ["src/validator.ts"],
+        "otel": {
+          "kind": "event",
+          "category": "error"
+        },
+        "dataSchema": {
+          "error.type": {
+            "type": "string",
+            "required": true
+          },
+          "error.message": {
+            "type": "string",
+            "required": true
+          },
+          "error.stage": {
+            "type": "string",
+            "required": false
           }
         }
       }
@@ -249024,7 +249304,7 @@ function capitalize(str3) {
 // src/commands/narrative/validate.ts
 function createValidateCommand2() {
   const command = new Command("validate");
-  command.description("Validate narrative template syntax, schema, and references").argument("<file>", "Path to .narrative.json file").option("--canvas <path>", "Override canvas file path for validation").option("--json", "Output violations as JSON").option("-q, --quiet", "Only show errors, suppress warnings").option("-d, --dir <path>", "Project directory (default: cwd)").action(async (file, options) => {
+  command.description("Validate narrative template syntax, schema, and references").argument("<file>", "Path to .narrative.json file").option("--canvas <path>", "Override canvas file path for validation").option("--execution <path>", "Execution file (.otel.json) for validating attribute references").option("--json", "Output violations as JSON").option("-q, --quiet", "Only show errors, suppress warnings").option("-d, --dir <path>", "Project directory (default: cwd)").action(async (file, options) => {
     try {
       const baseDir = options.dir || process.cwd();
       const narrativePath = resolvePath(file, baseDir);
@@ -249045,13 +249325,40 @@ function createValidateCommand2() {
           canvas = void 0;
         }
       }
+      let executionData;
+      if (options.execution) {
+        try {
+          const executionPath = resolvePath(options.execution, baseDir);
+          const execution = await loadExecution(executionPath);
+          const events = executionToEvents(execution);
+          const aggregates = computeAggregates(events);
+          const eventAttributes = /* @__PURE__ */ new Map();
+          for (const event of events) {
+            if (!eventAttributes.has(event.name)) {
+              eventAttributes.set(event.name, {});
+            }
+            const attrs = eventAttributes.get(event.name);
+            if (event.attributes) {
+              Object.assign(attrs, event.attributes);
+            }
+          }
+          executionData = { aggregates, eventAttributes };
+        } catch (error) {
+          console.error(
+            source_default.yellow("Warning:"),
+            `Failed to load execution file: ${error.message}`
+          );
+          console.error(source_default.gray("  Attribute validation will be skipped"));
+        }
+      }
       const validator = new NarrativeValidator();
       const context = {
         narrative,
         narrativePath,
         canvasPath,
         canvas,
-        basePath: baseDir
+        basePath: baseDir,
+        executionData
       };
       const result = await validator.validate(context);
       const violations = options.quiet ? result.violations.filter((v) => v.severity === "error") : result.violations;
@@ -249075,7 +249382,8 @@ function createValidateCommand2() {
             errors: errors.length,
             warnings: warnings.length,
             scenarioCount: narrative.scenarios.length,
-            hasDefault: narrative.scenarios.some((s) => s.condition.default)
+            hasDefault: narrative.scenarios.some((s) => s.condition.default),
+            attributeValidation: executionData ? "enabled" : "skipped"
           }
         };
         console.log(JSON.stringify(output, null, 2));
@@ -249140,6 +249448,17 @@ ${icon} ${severity}: ${violation.message}`);
         if (canvasPath) {
           console.log(source_default.gray(`  \u2022 Canvas: ${narrative.canvas || canvasPath}`));
         }
+        if (executionData) {
+          console.log(
+            source_default.gray("  \u2022 Attribute validation:"),
+            source_default.green("enabled")
+          );
+        } else {
+          console.log(
+            source_default.gray("  \u2022 Attribute validation:"),
+            source_default.gray("skipped (use --execution to enable)")
+          );
+        }
         console.log();
       }
       if (errors.length > 0) {