@rune-kit/rune 2.6.0 → 2.8.0

package/README.md

@@ -12,6 +12,7 @@
   <a href="https://rune-kit.github.io/rune"><img src="https://img.shields.io/badge/Landing_Page-rune--kit.github.io-blue?style=for-the-badge" alt="Landing Page"></a>
   <a href="https://rune-kit.github.io/rune#pricing"><img src="https://img.shields.io/badge/Pro_%2449-lifetime-blueviolet?style=for-the-badge" alt="Rune Pro $49"></a>
   <a href="https://rune-kit.github.io/rune#pricing"><img src="https://img.shields.io/badge/Business_%24149-lifetime-orange?style=for-the-badge" alt="Rune Business $149"></a>
+  <a href="https://t.me/xlabs_updates"><img src="https://img.shields.io/badge/Telegram-Updates-26A5E4?style=for-the-badge&logo=telegram&logoColor=white" alt="Telegram Updates"></a>
 </p>
 
 <p align="center">
@@ -82,15 +83,30 @@ _Methodology: Claude Code CLI headless mode (`claude -p --output-format json`),
 
 ---
 
-## What's New (v2.6.0)
+## What's New (v2.8.0)
 
-- **Mesh Signals** — event-driven skill communication via frontmatter. Skills declare `emit` and `listen` signals; compiler builds a signal graph in `skill-index.json`. 17 signals across 15 core skills. Completes the spec-kit trilogy: Tier Override → Mesh Contract → Mesh Signals
+- **Anti-Loop Intelligence** — 7 core skills enriched with execution loop detection, saturation analysis, error pattern matching, artifact folding, budget-aware progression, and recovery policy routing
+- **cook v2.1.0** — observation/effect ratio tracking (detects stuck agents reading without writing) + budget-aware phase progression with hard caps on replans, quality retries, and session tool calls
+- **completion-gate v1.8.0** — execution loop audit: classifies tool calls as observation vs effect, flags imbalanced ratios and repeating sequences in gate reports
+- **scout v0.3.0** — info saturation detection: tracks entity discovery rate and content similarity to stop scanning when diminishing returns detected
+- **research v0.4.0** — diminishing returns detection: monitors new-entity ratio and result overlap across searches to skip redundant queries
+- **context-engine v0.9.0** — artifact folding: large tool outputs (>4000 chars or >120 lines) saved to `.rune/artifacts/` with compact preview in context
+- **debug v1.0.0** — known error pattern catalog: 8 error archetypes (STATELESS_LOSS, MODULE_NOT_FOUND, TYPE_MISMATCH, ASYNC_DEADLOCK, etc.) with recovery hints + error fingerprinting for dedup
+- **fix v0.8.0** — recovery policy matrix: classifies errors into 8 types (INPUT_REQUIRED→PROMPT_USER, TIMEOUT→RETRY, POLICY_BLOCKED→ABORT, etc.) before attempting fixes
+- **Source attribution cleanup** — removed all enrichment credit lines from skill files to reduce context noise
+
+### Previous (v2.7.0)
+
+- **Deep Knowledge** — 8 core skills enriched with battle-tested patterns: context compaction, structured cumulative memory, milestone analysis, multi-provider adapters, AI-driven interview, prompt-as-API-contract, token budget tracking, incremental stream processing
+- **946 Tests** — compiler + signals + hooks + scripts + status + visualizer validation
+
+### Previous (v2.6.0)
+
+- **Mesh Signals** — event-driven skill communication via frontmatter. Skills declare `emit` and `listen` signals; compiler builds a signal graph in `skill-index.json`. 17 signals across 15 core skills
 - **Signal Validation** — `scripts/validate-signals.js` checks orphan listeners (hard error), unlistened emitters (warning), signal naming conventions
 - **Mesh Contract** (v2.5.0) — `.rune/contract.md` project-level invariants enforced by cook + sentinel as hard gates
-- **Compiled Intent Mesh** (v2.5.0) — compile-time `skill-index.json` with intent keywords, mesh graph, chain predictions
 - **Tier Override** — Pro/Business packs override Free packs with skill-level merging
 - **Scripts Bundling** — compiler copies `scripts/` directories, resolves `{scripts_dir}` placeholders
-- **566 Tests** — compiler + signals + hooks + scripts validation
 
 ### Signal Graph
 
@@ -447,11 +463,11 @@ See [docs/MULTI-PLATFORM.md](docs/MULTI-PLATFORM.md) for the full architecture.
 Core Skills:       61 (L0: 1 │ L1: 5 │ L2: 28 │ L3: 27)
 Extension Packs:   14 free + 4 pro + 4 business
 Mesh Connections:  200+ cross-references
-Mesh Signals:      17 signals across 15 skills (emit/listen graph)
+Mesh Signals:      57 signals across 66 skills (emit/listen graph)
 Connections/Skill: 3.4 avg
 Platforms:         8 (Claude Code, Cursor, Windsurf, Antigravity, Codex, OpenCode, OpenClaw, Generic)
 Compiler:          ~1400 LOC (parser + 8 transforms + 8 adapters + CLI)
-Tests:             566 (compiler + signals + hooks + scripts)
+Tests:             946 (compiler + signals + status + visualizer + hooks + scripts)
 Pack Depth:        22 packs total (14 free + 4 pro + 4 business, all free packs rated Deep)
 ```
 

package/compiler/__tests__/executive-dashboards.test.js

@@ -0,0 +1,285 @@
+import assert from 'node:assert';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const BUSINESS_DIR = path.resolve(__dirname, '../../../Business');
+const REPORT_TEMPLATES_DIR = path.join(BUSINESS_DIR, 'report-templates');
+const SKILLS_DIR = path.resolve(__dirname, '../../skills');
+
+// ─── HTML report template validation ──────────────────────────────
+
+// Skip Business tier tests when Business repo is not available (CI)
+const HAS_BUSINESS = existsSync(BUSINESS_DIR);
+
+(HAS_BUSINESS ? describe : describe.skip)('Business report-templates directory', () => {
+  test('report-templates directory exists', () => {
+    assert.ok(existsSync(REPORT_TEMPLATES_DIR), 'Expected Business/report-templates/ to exist');
+  });
+
+  test('retro-business.html exists', () => {
+    assert.ok(
+      existsSync(path.join(REPORT_TEMPLATES_DIR, 'retro-business.html')),
+      'Expected retro-business.html template',
+    );
+  });
+
+  test('autopsy-executive.html exists', () => {
+    assert.ok(
+      existsSync(path.join(REPORT_TEMPLATES_DIR, 'autopsy-executive.html')),
+      'Expected autopsy-executive.html template',
+    );
+  });
+});
+
+describe('retro-business.html template', () => {
+  const filePath = path.join(REPORT_TEMPLATES_DIR, 'retro-business.html');
+  if (!existsSync(filePath)) return;
+  const content = readFileSync(filePath, 'utf-8');
+
+  test('is valid HTML with doctype', () => {
+    assert.ok(content.startsWith('<!DOCTYPE html>'), 'Must start with DOCTYPE');
+    assert.ok(content.includes('<html'), 'Must have html tag');
+    assert.ok(content.includes('</html>'), 'Must close html tag');
+  });
+
+  test('is self-contained (no external CSS/JS)', () => {
+    assert.ok(!content.includes('href="http'), 'No external CSS links');
+    assert.ok(!content.includes('src="http'), 'No external JS scripts');
+    assert.ok(!content.includes('cdn.'), 'No CDN references');
+  });
+
+  test('has inline styles', () => {
+    assert.ok(content.includes('<style>'), 'Must have inline style block');
+  });
+
+  test('has print-friendly styles', () => {
+    assert.ok(content.includes('@media print'), 'Must have print media query');
+    assert.ok(content.includes('@page'), 'Must have @page rule for PDF export');
+  });
+
+  test('has KPI card placeholders', () => {
+    assert.ok(content.includes('{{sprint_velocity}}'), 'Missing sprint_velocity placeholder');
+    assert.ok(content.includes('{{mrr}}'), 'Missing MRR placeholder');
+    assert.ok(content.includes('{{sla_pct}}'), 'Missing SLA placeholder');
+    assert.ok(content.includes('{{compliance_score}}'), 'Missing compliance_score placeholder');
+  });
+
+  test('has domain performance sections', () => {
+    assert.ok(content.includes('Engineering'), 'Missing Engineering domain');
+    assert.ok(content.includes('Revenue'), 'Missing Revenue domain');
+    assert.ok(content.includes('Support'), 'Missing Support domain');
+    assert.ok(content.includes('Finance'), 'Missing Finance domain');
+  });
+
+  test('has team health table', () => {
+    assert.ok(content.includes('Team Health'), 'Missing Team Health section');
+    assert.ok(content.includes('{{team_name}}'), 'Missing team_name placeholder');
+    assert.ok(content.includes('{{team_lead}}'), 'Missing team_lead placeholder');
+  });
+
+  test('has compliance status section', () => {
+    assert.ok(content.includes('Compliance Status'), 'Missing Compliance Status section');
+    assert.ok(content.includes('{{framework}}'), 'Missing framework placeholder');
+  });
+
+  test('has key insights section (wins + risks)', () => {
+    assert.ok(content.includes('Key Insights'), 'Missing Key Insights section');
+    assert.ok(content.includes('Wins'), 'Missing Wins subsection');
+    assert.ok(content.includes('Risks'), 'Missing Risks subsection');
+  });
+
+  test('has Rune Business footer', () => {
+    assert.ok(content.includes('Rune Business'), 'Missing Rune Business branding');
+    assert.ok(content.includes('retro --business'), 'Missing retro --business reference');
+  });
+
+  test('has trend delta placeholders for KPIs', () => {
+    assert.ok(content.includes('{{velocity_delta}}'), 'Missing velocity trend');
+    assert.ok(content.includes('{{mrr_delta}}'), 'Missing MRR trend');
+  });
+
+  test('uses CSS custom properties for theming', () => {
+    assert.ok(content.includes(':root'), 'Must use CSS custom properties');
+    assert.ok(content.includes('--bg'), 'Missing --bg variable');
+    assert.ok(content.includes('--accent'), 'Missing --accent variable');
+  });
+});
+
+describe('autopsy-executive.html template', () => {
+  const filePath = path.join(REPORT_TEMPLATES_DIR, 'autopsy-executive.html');
+  if (!existsSync(filePath)) return;
+  const content = readFileSync(filePath, 'utf-8');
+
+  test('is valid HTML with doctype', () => {
+    assert.ok(content.startsWith('<!DOCTYPE html>'), 'Must start with DOCTYPE');
+    assert.ok(content.includes('<html'), 'Must have html tag');
+    assert.ok(content.includes('</html>'), 'Must close html tag');
+  });
+
+  test('is self-contained (no external CSS/JS)', () => {
+    assert.ok(!content.includes('href="http'), 'No external CSS links');
+    assert.ok(!content.includes('src="http'), 'No external JS scripts');
+    assert.ok(!content.includes('cdn.'), 'No CDN references');
+  });
+
+  test('has print-friendly styles', () => {
+    assert.ok(content.includes('@media print'), 'Must have print media query');
+    assert.ok(content.includes('@page'), 'Must have @page rule');
+  });
+
+  test('has SVG health ring', () => {
+    assert.ok(content.includes('<svg'), 'Must have inline SVG');
+    assert.ok(content.includes('<circle'), 'Must have SVG circle for health ring');
+    assert.ok(content.includes('stroke-dasharray'), 'Must use dasharray for progress ring');
+  });
+
+  test('has health score placeholder', () => {
+    assert.ok(content.includes('{{health_score}}'), 'Missing health_score placeholder');
+    assert.ok(content.includes('{{risk_tier}}'), 'Missing risk_tier placeholder');
+    assert.ok(content.includes('{{score_color}}'), 'Missing score_color placeholder');
+  });
+
+  test('has six health dimensions', () => {
+    assert.ok(content.includes('Complexity'), 'Missing Complexity dimension');
+    assert.ok(content.includes('Test Coverage'), 'Missing Test Coverage dimension');
+    assert.ok(content.includes('Documentation'), 'Missing Documentation dimension');
+    assert.ok(content.includes('Dependencies'), 'Missing Dependencies dimension');
+    assert.ok(content.includes('Code Smells'), 'Missing Code Smells dimension');
+    assert.ok(content.includes('Maintenance'), 'Missing Maintenance dimension');
+  });
+
+  test('has module health table', () => {
+    assert.ok(content.includes('Module Health'), 'Missing Module Health section');
+    assert.ok(content.includes('{{module_name}}'), 'Missing module_name placeholder');
+    assert.ok(content.includes('{{module_score}}'), 'Missing module_score placeholder');
+  });
+
+  test('has surgery queue section', () => {
+    assert.ok(content.includes('Surgery Queue'), 'Missing Surgery Queue section');
+    assert.ok(content.includes('{{surgery_module}}'), 'Missing surgery_module placeholder');
+    assert.ok(content.includes('{{surgery_pattern}}'), 'Missing surgery_pattern placeholder');
+  });
+
+  test('has risk assessment section', () => {
+    assert.ok(content.includes('Risk Assessment'), 'Missing Risk Assessment section');
+    assert.ok(content.includes('Git Archaeology'), 'Missing Git Archaeology section');
+  });
+
+  test('has cross-domain impact table', () => {
+    assert.ok(content.includes('Cross-Domain Impact'), 'Missing Cross-Domain Impact section');
+    assert.ok(content.includes('{{domain_name}}'), 'Missing domain_name placeholder');
+  });
+
+  test('has recommended actions', () => {
+    assert.ok(content.includes('Recommended Actions'), 'Missing Recommended Actions section');
+  });
+
+  test('has Rune Business footer', () => {
+    assert.ok(content.includes('Rune Business'), 'Missing Rune Business branding');
+    assert.ok(content.includes('autopsy --executive'), 'Missing autopsy --executive reference');
+  });
+
+  test('has board-ready label', () => {
+    assert.ok(content.includes('Board-ready'), 'Should mention board-ready format');
+  });
+});
+
+// ─── Skill integration validation ─────────────────────────────────
+
+describe('retro skill --business integration', () => {
+  const retroPath = path.join(SKILLS_DIR, 'retro', 'SKILL.md');
+  const content = readFileSync(retroPath, 'utf-8');
+
+  test('retro has --business trigger', () => {
+    assert.ok(content.includes('retro --business'), 'retro should document --business mode');
+  });
+
+  test('retro --business references HTML report', () => {
+    assert.ok(content.includes('.html'), 'retro --business should reference HTML output');
+  });
+
+  test('retro --business references cross-domain data', () => {
+    assert.ok(
+      content.includes('Revenue') || content.includes('revenue'),
+      'retro --business should reference revenue domain',
+    );
+    assert.ok(
+      content.includes('Support') || content.includes('support'),
+      'retro --business should reference support domain',
+    );
+    assert.ok(
+      content.includes('Finance') || content.includes('finance'),
+      'retro --business should reference finance domain',
+    );
+  });
+
+  test('retro --business references org config', () => {
+    assert.ok(content.includes('.rune/org/org.md'), 'retro --business should reference org config');
+  });
+
+  test('retro --business has graceful degradation', () => {
+    assert.ok(
+      content.includes('Graceful Degradation') || content.includes('graceful'),
+      'retro --business should handle missing Business pack gracefully',
+    );
+  });
+
+  test('retro --business references report template', () => {
+    assert.ok(content.includes('retro-business.html'), 'retro should reference the HTML template file');
+  });
+});
+
+describe('autopsy skill --executive integration', () => {
+  const autopsyPath = path.join(SKILLS_DIR, 'autopsy', 'SKILL.md');
+  const content = readFileSync(autopsyPath, 'utf-8');
+
+  test('autopsy has --executive mode', () => {
+    assert.ok(content.includes('--executive'), 'autopsy should document --executive mode');
+  });
+
+  test('autopsy --executive references HTML report', () => {
+    assert.ok(
+      content.includes('EXECUTIVE-HEALTH.html'),
+      'autopsy --executive should reference EXECUTIVE-HEALTH.html output',
+    );
+  });
+
+  test('autopsy --executive references SVG health ring', () => {
+    assert.ok(
+      content.includes('SVG') || content.includes('svg'),
+      'autopsy --executive should reference SVG health ring',
+    );
+  });
+
+  test('autopsy --executive has color coding table', () => {
+    assert.ok(
+      content.includes('Color Coding') || content.includes('color'),
+      'autopsy --executive should define color coding',
+    );
+  });
+
+  test('autopsy --executive references org config', () => {
+    assert.ok(content.includes('.rune/org/org.md'), 'autopsy --executive should reference org config for team mapping');
+  });
+
+  test('autopsy --executive references report template', () => {
+    assert.ok(content.includes('autopsy-executive.html'), 'autopsy should reference the HTML template file');
+  });
+
+  test('autopsy --executive has cross-domain impact', () => {
+    assert.ok(
+      content.includes('Cross-Domain') || content.includes('cross-domain'),
+      'autopsy --executive should map to business domains',
+    );
+  });
+
+  test('autopsy --executive has graceful degradation', () => {
+    assert.ok(
+      content.includes('Graceful Degradation') || content.includes('graceful'),
+      'autopsy --executive should handle missing Business pack',
+    );
+  });
+});

package/compiler/__tests__/inject.test.js

@@ -0,0 +1,128 @@
+import assert from 'node:assert';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SKILLS_DIR = path.resolve(__dirname, '../../skills');
+const PRO_DIR = path.resolve(__dirname, '../../../Pro/extensions');
+const BUSINESS_DIR = path.resolve(__dirname, '../../../Business/extensions');
+
+// Skip Pro/Business tier tests when repos are not available (CI)
+const HAS_PRO = existsSync(PRO_DIR);
+
+// Collect known Free core skill names
+const knownSkills = new Set();
+if (existsSync(SKILLS_DIR)) {
+  for (const entry of readdirSync(SKILLS_DIR, { withFileTypes: true })) {
+    if (entry.isDirectory() && existsSync(path.join(SKILLS_DIR, entry.name, 'SKILL.md'))) {
+      knownSkills.add(entry.name);
+    }
+  }
+}
+
+(HAS_PRO ? describe : describe.skip)('inject.json format validation', () => {
+  const packDirs = [];
+
+  // Collect all extension dirs that might have inject.json
+  for (const extDir of [PRO_DIR, BUSINESS_DIR]) {
+    if (!existsSync(extDir)) continue;
+    for (const entry of readdirSync(extDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const injectPath = path.join(extDir, entry.name, 'inject.json');
+      if (existsSync(injectPath)) {
+        packDirs.push({ name: entry.name, dir: path.join(extDir, entry.name), injectPath });
+      }
+    }
+  }
+
+  test('at least one inject.json exists in Pro packs', () => {
+    assert.ok(packDirs.length > 0, 'Expected at least one pack with inject.json');
+  });
+
+  for (const pack of packDirs) {
+    describe(`${pack.name}/inject.json`, () => {
+      let config;
+
+      test('is valid JSON', () => {
+        const raw = readFileSync(pack.injectPath, 'utf-8');
+        config = JSON.parse(raw);
+        assert.ok(config, 'inject.json should parse as valid JSON');
+      });
+
+      test('has injections array', () => {
+        if (!config) return;
+        assert.ok(Array.isArray(config.injections), 'must have injections array');
+        assert.ok(config.injections.length > 0, 'must have at least one injection rule');
+      });
+
+      test('has description field', () => {
+        if (!config) return;
+        assert.ok(config.description, 'should have a description field');
+      });
+
+      test('each rule has required fields', () => {
+        if (!config) return;
+        for (const rule of config.injections) {
+          assert.ok(rule.skill, `rule must have "skill" field: ${JSON.stringify(rule)}`);
+          assert.ok(rule.ref, `rule must have "ref" field: ${JSON.stringify(rule)}`);
+          assert.ok(rule.context, `rule must have "context" field: ${JSON.stringify(rule)}`);
+        }
+      });
+
+      test('target skills exist in Free core', () => {
+        if (!config) return;
+        for (const rule of config.injections) {
+          assert.ok(knownSkills.has(rule.skill), `target skill "${rule.skill}" not found in Free core skills`);
+        }
+      });
+
+      test('reference files exist', () => {
+        if (!config) return;
+        for (const rule of config.injections) {
+          const refPath = path.join(pack.dir, rule.ref);
+          assert.ok(existsSync(refPath), `reference file "${rule.ref}" not found at ${refPath}`);
+        }
+      });
+
+      test('reference files are .md', () => {
+        if (!config) return;
+        for (const rule of config.injections) {
+          assert.ok(rule.ref.endsWith('.md'), `reference "${rule.ref}" should be a .md file`);
+        }
+      });
+
+      test('no duplicate skill targets within same pack', () => {
+        if (!config) return;
+        const seen = new Set();
+        for (const rule of config.injections) {
+          assert.ok(!seen.has(rule.skill), `duplicate injection target "${rule.skill}" in ${pack.name}`);
+          seen.add(rule.skill);
+        }
+      });
+    });
+  }
+});
+
+(HAS_PRO ? describe : describe.skip)('injection rule coverage', () => {
+  const expectedPacks = ['pro-product', 'pro-data-science', 'pro-sales', 'pro-support'];
+
+  for (const packName of expectedPacks) {
+    test(`${packName} has inject.json`, () => {
+      const injectPath = path.join(PRO_DIR, packName, 'inject.json');
+      assert.ok(existsSync(injectPath), `${packName} should have inject.json`);
+    });
+  }
+
+  test('total injection rules across all packs', () => {
+    let totalRules = 0;
+    for (const packName of expectedPacks) {
+      const injectPath = path.join(PRO_DIR, packName, 'inject.json');
+      if (!existsSync(injectPath)) continue;
+      const config = JSON.parse(readFileSync(injectPath, 'utf-8'));
+      totalRules += (config.injections || []).length;
+    }
+    assert.ok(totalRules >= 8, `should have at least 8 injection rules total, got ${totalRules}`);
+  });
+});

package/compiler/__tests__/orchestrators.test.js

@@ -0,0 +1,151 @@
+import assert from 'node:assert';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { parseSkill } from '../parser.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const BUSINESS_SKILLS_DIR = path.resolve(__dirname, '../../../Business/skills');
+
+// Signal naming pattern
+const SIGNAL_NAME_PATTERN = /^[a-z][a-z0-9]*(\.[a-z][a-z0-9]*)+$/;
+
+const ORCHESTRATORS = ['launch-product', 'quarterly-review', 'compliance-audit', 'customer-lifecycle'];
+
+// Skip Business tier tests when Business repo is not available (CI)
+const HAS_BUSINESS = existsSync(BUSINESS_SKILLS_DIR);
+
+(HAS_BUSINESS ? describe : describe.skip)('Business orchestrators', () => {
+  test('skills directory exists', () => {
+    assert.ok(existsSync(BUSINESS_SKILLS_DIR), `${BUSINESS_SKILLS_DIR} should exist`);
+  });
+
+  for (const name of ORCHESTRATORS) {
+    const skillPath = path.join(BUSINESS_SKILLS_DIR, name, 'SKILL.md');
+
+    describe(name, () => {
+      test('SKILL.md exists', () => {
+        assert.ok(existsSync(skillPath), `${skillPath} should exist`);
+      });
+
+      // Skip remaining tests if file doesn't exist (CI without Business repo)
+      if (!existsSync(skillPath)) return;
+
+      const content = readFileSync(skillPath, 'utf-8');
+      const parsed = parseSkill(content, skillPath);
+
+      test('has correct name', () => {
+        assert.strictEqual(parsed.name, name);
+      });
+
+      test('is L1 layer', () => {
+        assert.strictEqual(parsed.layer, 'L1', `${name} must be L1 orchestrator`);
+      });
+
+      test('uses opus model', () => {
+        assert.strictEqual(parsed.model, 'opus', `${name} should use opus for complex orchestration`);
+      });
+
+      test('has description', () => {
+        assert.ok(parsed.description.length > 50, `${name} should have a meaningful description`);
+      });
+
+      test('is context fork', () => {
+        assert.strictEqual(parsed.contextFork, true, `${name} should fork context`);
+      });
+
+      test('has emit signals', () => {
+        assert.ok(parsed.signals, `${name} must have signals`);
+        assert.ok(parsed.signals.emit.length > 0, `${name} must emit at least one signal`);
+      });
+
+      test('has listen signals', () => {
+        assert.ok(parsed.signals.listen.length > 0, `${name} must listen to at least one signal`);
+      });
+
+      test('all signals follow naming convention', () => {
+        for (const signal of [...parsed.signals.emit, ...parsed.signals.listen]) {
+          assert.ok(SIGNAL_NAME_PATTERN.test(signal), `signal "${signal}" must match lowercase.dot.notation`);
+        }
+      });
+
+      test('has HARD-GATE block', () => {
+        assert.ok(parsed.hardGates.length > 0, `${name} must have at least one HARD-GATE`);
+      });
+
+      test('has cross-references to other skills', () => {
+        assert.ok(parsed.crossRefs.length >= 3, `${name} should reference at least 3 other skills`);
+      });
+
+      test('has Workflow Phases section', () => {
+        assert.ok(parsed.sections.has('Workflow Phases'), `${name} must have ## Workflow Phases`);
+      });
+
+      test('has Signal Map section', () => {
+        assert.ok(parsed.sections.has('Signal Map'), `${name} must have ## Signal Map`);
+      });
+
+      test('has Cross-Domain Connections section', () => {
+        assert.ok(parsed.sections.has('Cross-Domain Connections'), `${name} must have ## Cross-Domain Connections`);
+      });
+
+      test('has Connections section', () => {
+        assert.ok(parsed.sections.has('Connections'), `${name} must have ## Connections`);
+      });
+
+      test('has Constraints section', () => {
+        assert.ok(parsed.sections.has('Constraints'), `${name} must have ## Constraints`);
+      });
+
+      test('references multiple domain packs (cross-domain)', () => {
+        const body = parsed.body;
+        const domains = ['finance', 'legal', 'hr', 'product', 'sales', 'support', 'enterprise-search', 'data-science'];
+        const referencedDomains = domains.filter((d) => body.toLowerCase().includes(d));
+        assert.ok(
+          referencedDomains.length >= 3,
+          `${name} must reference at least 3 domains, found: ${referencedDomains.join(', ')}`,
+        );
+      });
+
+      test('emits business.* signals', () => {
+        const businessSignals = parsed.signals.emit.filter((s) => s.startsWith('business.'));
+        assert.ok(businessSignals.length > 0, `${name} must emit at least one business.* signal`);
+      });
+
+      test('body is substantial (300-500+ lines)', () => {
+        const lineCount = content.split('\n').length;
+        assert.ok(lineCount >= 100, `${name} should be at least 100 lines, got ${lineCount}`);
+      });
+    });
+  }
+});
+
+(HAS_BUSINESS ? describe : describe.skip)('orchestrator signal consistency', () => {
+  // Verify orchestrators don't declare signals that overlap with each other
+  const allEmitted = new Set();
+  const duplicates = [];
+
+  for (const name of ORCHESTRATORS) {
+    const skillPath = path.join(BUSINESS_SKILLS_DIR, name, 'SKILL.md');
+    if (!existsSync(skillPath)) continue;
+
+    const content = readFileSync(skillPath, 'utf-8');
+    const parsed = parseSkill(content, skillPath);
+
+    for (const signal of parsed.signals.emit) {
+      if (allEmitted.has(signal)) {
+        duplicates.push({ signal, skill: name });
+      }
+      allEmitted.add(signal);
+    }
+  }
+
+  test('no duplicate emit signals across orchestrators', () => {
+    assert.strictEqual(
+      duplicates.length,
+      0,
+      `Duplicate signals: ${duplicates.map((d) => `${d.signal} (${d.skill})`).join(', ')}`,
+    );
+  });
+});