@rune-kit/rune 2.13.0 → 2.14.0

package/compiler/__tests__/diversity-score.test.js

@@ -0,0 +1,117 @@
+/**
+ * Diversity score for Design-It-Twice mode.
+ *
+ * Computes pairwise Jaccard similarity over feature vectors of N designs.
+ * Returns 1 - mean(similarity).
+ *
+ * Used by brainstorm v0.6 Step 3.5 to gate re-spawning when designs are too similar.
+ */
+
+import assert from 'node:assert';
+import { describe, test } from 'node:test';
+
+function jaccard(a, b) {
+  const setA = new Set(a);
+  const setB = new Set(b);
+  const intersect = new Set([...setA].filter((x) => setB.has(x)));
+  const union = new Set([...setA, ...setB]);
+  if (union.size === 0) return 1;
+  return intersect.size / union.size;
+}
+
+function diversityScore(designs) {
+  if (designs.length < 2) return 1;
+  const pairs = [];
+  for (let i = 0; i < designs.length; i++) {
+    for (let j = i + 1; j < designs.length; j++) {
+      pairs.push(jaccard(designs[i], designs[j]));
+    }
+  }
+  const mean = pairs.reduce((a, b) => a + b, 0) / pairs.length;
+  return 1 - mean;
+}
+
+// Encoding: a feature vector is a list of feature tokens.
+// Examples:
+//   ["methods:1", "returns:1", "adapters:0", "deps:1", "paradigm:minimal", "async:no", "stream:no"]
+//   ["methods:8", "returns:5", "adapters:3", "deps:5", "paradigm:extensible", "async:yes", "stream:yes"]
+
+describe('diversity score', () => {
+  test('identical designs return diversity 0', () => {
+    const d1 = ['methods:3', 'paradigm:minimal'];
+    const d2 = ['methods:3', 'paradigm:minimal'];
+    assert.strictEqual(diversityScore([d1, d2]), 0);
+  });
+
+  test('disjoint designs return diversity 1', () => {
+    const d1 = ['methods:3', 'paradigm:minimal'];
+    const d2 = ['methods:8', 'paradigm:extensible'];
+    assert.strictEqual(diversityScore([d1, d2]), 1);
+  });
+
+  test('half-overlap returns diversity 0.5', () => {
+    const d1 = ['methods:3', 'paradigm:minimal'];
+    const d2 = ['methods:3', 'paradigm:extensible'];
+    // jaccard = 1/3 (intersection {methods:3}, union {methods:3, paradigm:minimal, paradigm:extensible})
+    // diversity = 1 - 1/3 = 0.6667
+    const diversity = diversityScore([d1, d2]);
+    assert.ok(Math.abs(diversity - 0.6667) < 0.001, `expected ~0.6667, got ${diversity}`);
+  });
+
+  test('three radically different designs pass 0.6 floor', () => {
+    const c1 = ['methods:2', 'returns:1', 'paradigm:minimal', 'adapters:0', 'async:no'];
+    const c2 = ['methods:8', 'returns:5', 'paradigm:extensible', 'adapters:0', 'async:yes'];
+    const c4 = ['methods:3', 'returns:2', 'paradigm:ports-adapters', 'adapters:2', 'async:no'];
+    const diversity = diversityScore([c1, c2, c4]);
+    assert.ok(diversity >= 0.6, `expected >=0.6, got ${diversity}`);
+  });
+
+  test('three near-identical designs fail 0.4 floor', () => {
+    const a = ['methods:3', 'returns:1', 'paradigm:minimal'];
+    const b = ['methods:3', 'returns:1', 'paradigm:minimal'];
+    const c = ['methods:3', 'returns:1', 'paradigm:minimal'];
+    const diversity = diversityScore([a, b, c]);
+    assert.ok(diversity < 0.4, `expected <0.4, got ${diversity}`);
+  });
+
+  test('marginal designs land in 0.4-0.59 zone (warn tier)', () => {
+    // 6/9 features shared between each pair → jaccard ≈ 0.50, diversity ≈ 0.50
+    const a = ['m:3', 'r:1', 'p:m', 'a:0', 'q:x', 'e:y'];
+    const b = ['m:3', 'r:1', 'p:m', 'a:0', 'q:x', 'e:z'];
+    const c = ['m:3', 'r:1', 'p:m', 'a:0', 'q:y', 'e:z'];
+    const diversity = diversityScore([a, b, c]);
+    assert.ok(diversity >= 0.3 && diversity < 0.6, `expected 0.3-0.59, got ${diversity}`);
+  });
+
+  test('single design returns diversity 1 (degenerate)', () => {
+    assert.strictEqual(diversityScore([['x']]), 1);
+  });
+
+  test('four designs (when C4 included) — diverse set passes', () => {
+    const c1 = ['methods:2', 'paradigm:minimal'];
+    const c2 = ['methods:8', 'paradigm:extensible'];
+    const c3 = ['methods:1', 'paradigm:default-light'];
+    const c4 = ['methods:3', 'paradigm:ports-adapters'];
+    const diversity = diversityScore([c1, c2, c3, c4]);
+    assert.ok(diversity >= 0.6, `expected >=0.6, got ${diversity}`);
+  });
+});
+
+describe('threshold gate', () => {
+  test('floor 0.4 — below triggers re-spawn', () => {
+    const FLOOR = 0.4;
+    const lowDiversity = 0.3;
+    assert.strictEqual(lowDiversity < FLOOR, true);
+  });
+
+  test('threshold 0.6 — proceed without warning', () => {
+    const THRESHOLD = 0.6;
+    const goodDiversity = 0.7;
+    assert.strictEqual(goodDiversity >= THRESHOLD, true);
+  });
+
+  test('warn zone 0.4-0.59 — surface to user', () => {
+    const value = 0.5;
+    assert.ok(value >= 0.4 && value < 0.6);
+  });
+});

package/compiler/__tests__/improve-architecture.test.js

@@ -0,0 +1,171 @@
+/**
+ * improve-architecture skill — structural and vocabulary tests.
+ *
+ * Validates:
+ *   - SKILL.md parses, version 0.1.0, layer L2, model opus
+ *   - Required reference files exist (language, deepening, interface-design, scoring)
+ *   - evals.md exists with >=4 evals across categories
+ *   - Vocabulary discipline: skill body + references do NOT use banned aliases
+ *   - Proposal payload schema shape (sample YAML in SKILL.md parses)
+ */
+
+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 SKILL_DIR = path.resolve(__dirname, '../../skills/improve-architecture');
+
+const REQUIRED_FILES = [
+  'SKILL.md',
+  'references/language.md',
+  'references/deepening.md',
+  'references/interface-design.md',
+  'references/scoring.md',
+  'evals.md',
+];
+
+// --- Files exist ---
+
+describe('improve-architecture file presence', () => {
+  for (const f of REQUIRED_FILES) {
+    test(`${f} exists`, () => {
+      const p = path.join(SKILL_DIR, f);
+      assert.ok(existsSync(p), `missing: ${f}`);
+    });
+  }
+});
+
+// --- SKILL.md parses correctly ---
+
+test('SKILL.md frontmatter — name, version, layer, model', () => {
+  const skillPath = path.join(SKILL_DIR, 'SKILL.md');
+  const parsed = parseSkill(readFileSync(skillPath, 'utf-8'));
+  assert.strictEqual(parsed.frontmatter.name, 'improve-architecture');
+  assert.strictEqual(parsed.frontmatter.metadata.version, '0.1.0');
+  assert.strictEqual(parsed.frontmatter.metadata.layer, 'L2');
+  assert.strictEqual(parsed.frontmatter.metadata.model, 'opus');
+});
+
+test('SKILL.md emit includes architecture.shallow.flagged + architecture.deletion.passed', () => {
+  const skillPath = path.join(SKILL_DIR, 'SKILL.md');
+  const content = readFileSync(skillPath, 'utf-8');
+  assert.ok(/emit:.*architecture\.shallow\.flagged/.test(content), 'emits architecture.shallow.flagged');
+  assert.ok(/emit:.*architecture\.deletion\.passed/.test(content), 'emits architecture.deletion.passed');
+});
+
+// --- Required reference content ---
+
+test('language.md defines all 8 controlled terms', () => {
+  const content = readFileSync(path.join(SKILL_DIR, 'references/language.md'), 'utf-8');
+  const required = ['Module', 'Interface', 'Implementation', 'Depth', 'Seam', 'Adapter', 'Leverage', 'Locality'];
+  for (const term of required) {
+    // Each term should appear as a heading line `### Term`
+    assert.ok(new RegExp(`^### ${term}\\b`, 'm').test(content), `language.md missing heading for "${term}"`);
+  }
+});
+
+test('deepening.md lists all 4 dependency categories', () => {
+  const content = readFileSync(path.join(SKILL_DIR, 'references/deepening.md'), 'utf-8');
+  for (const cat of ['In-process', 'Local-substitutable', 'Remote-owned', 'True-external']) {
+    assert.ok(content.includes(cat), `deepening.md missing dependency category "${cat}"`);
+  }
+});
+
+test('scoring.md provides numeric rubric for depth/leverage/locality', () => {
+  const content = readFileSync(path.join(SKILL_DIR, 'references/scoring.md'), 'utf-8');
+  for (const metric of ['## Depth (1–5)', '## Leverage (1–5)', '## Locality (1–5)']) {
+    assert.ok(content.includes(metric), `scoring.md missing section "${metric}"`);
+  }
+  // Deletion test verdict enum
+  for (const verdict of ['vanish', 'concentrate', 'redistribute']) {
+    assert.ok(content.includes(verdict), `scoring.md missing deletion-test verdict "${verdict}"`);
+  }
+});
+
+// --- Eval coverage ---
+
+test('evals.md has >=4 evals across categories', () => {
+  const content = readFileSync(path.join(SKILL_DIR, 'evals.md'), 'utf-8');
+  const evalMatches = content.match(/^## Eval: E\d+/gm) || [];
+  assert.ok(evalMatches.length >= 4, `expected >=4 evals, found ${evalMatches.length}`);
+
+  for (const cat of ['happy-path', 'edge-case', 'adversarial', 'jailbreak']) {
+    assert.ok(content.includes(cat), `evals.md missing category "${cat}"`);
+  }
+});
+
+// --- Vocabulary discipline: banned aliases in narrative prose ---
+
+describe('vocabulary discipline', () => {
+  // Skip narrative scan inside reference files that explicitly enumerate banned terms
+  // (language.md lists "Avoid:" rules — those mentions are intentional)
+  const SKIPPED_FILES = ['references/language.md'];
+
+  // Banned alias terms in skill narrative.
+  // We allow them inside fenced code blocks AND inside lines starting with "Avoid:" or "Banned"
+  // to permit legitimate doctrine prose ("don't say boundary").
+  const BANNED_ALIASES = ['boundary', 'component', 'service'];
+
+  for (const f of REQUIRED_FILES) {
+    if (SKIPPED_FILES.includes(f) || f === 'evals.md') continue;
+    test(`${f} narrative has no banned aliases`, () => {
+      const content = readFileSync(path.join(SKILL_DIR, f), 'utf-8');
+      const lines = content.split('\n');
+      let inFence = false;
+      const violations = [];
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim().startsWith('```')) {
+          inFence = !inFence;
+          continue;
+        }
+        if (inFence) continue;
+        // Skip lines that explicitly call out banned terms
+        const trimmed = line.trim();
+        if (
+          trimmed.startsWith('*Avoid*') ||
+          trimmed.startsWith('Avoid:') ||
+          trimmed.startsWith('Banned') ||
+          trimmed.startsWith('- **') || // banned-framings list items
+          /["“”'].*("|”|')\s*$/.test(trimmed) || // quoted phrases like "service"
+          line.includes('banned ') // doctrine sentences mentioning banned X
+        ) {
+          continue;
+        }
+        for (const bad of BANNED_ALIASES) {
+          // Match whole word, not substring (so "microservice" wouldn't trigger "service" only when it's a standalone word)
+          if (new RegExp(`\\b${bad}\\b`, 'i').test(line) && !line.includes(`"${bad}"`)) {
+            violations.push(`${f}:${i + 1}: ${line.trim()}`);
+            break;
+          }
+        }
+      }
+      assert.deepStrictEqual(violations, [], `vocabulary violations in ${f}:\n${violations.join('\n')}`);
+    });
+  }
+});
+
+// --- Proposal payload sample is parseable ---
+
+test('SKILL.md sample proposal payload is well-formed YAML-ish', () => {
+  const content = readFileSync(path.join(SKILL_DIR, 'SKILL.md'), 'utf-8');
+  // Find the architecture.proposal block
+  const match = content.match(/architecture\.proposal:[\s\S]*?(?=\n```|\n\n##)/);
+  assert.ok(match, 'SKILL.md missing architecture.proposal sample');
+  const block = match[0];
+  // Must include required fields
+  for (const field of [
+    'module_path:',
+    'current:',
+    'target:',
+    'dependency_category:',
+    'suggested_seam:',
+    'adapters_planned:',
+  ]) {
+    assert.ok(block.includes(field), `proposal payload missing field "${field}"`);
+  }
+});

package/compiler/__tests__/openclaw-adapter.test.js

@@ -115,10 +115,9 @@ test('generateManifest defaults version when missing', () => {
 });
 
 test('generateManifest declares artifact convention for OpenClaw skills', () => {
-  const manifest = openclaw.generateManifest(
-    [{ name: 'cook', layer: 'L1', group: 'orchestrator' }],
-    { version: '1.0.0' },
-  );
+  const manifest = openclaw.generateManifest([{ name: 'cook', layer: 'L1', group: 'orchestrator' }], {
+    version: '1.0.0',
+  });
   assert.ok(manifest.artifactConvention, 'artifactConvention field exists');
   assert.ok(Array.isArray(manifest.artifactConvention.outputDirPriority), 'outputDirPriority is array');
   assert.ok(manifest.artifactConvention.outputDirPriority.length >= 4, 'at least 4 fallback tiers');
@@ -129,12 +128,18 @@ test('generateManifest declares artifact convention for OpenClaw skills', () =>
   assert.ok(manifest.artifactConvention.outputContract, 'outputContract documented');
   assert.strictEqual(manifest.artifactConvention.outputContract.exitCodes[0], 'success');
   assert.strictEqual(manifest.artifactConvention.outputContract.exitCodes[4], 'timeout with partial results (accept)');
-  assert.strictEqual(manifest.artifactConvention.outputContract.exitCodes[124], 'timeout with zero results (retry or abort)');
+  assert.strictEqual(
+    manifest.artifactConvention.outputContract.exitCodes[124],
+    'timeout with zero results (retry or abort)',
+  );
 });
 
 test('generateManifest description scales with skill count', () => {
   const fewSkills = openclaw.generateManifest(
-    [{ name: 'cook', layer: 'L1' }, { name: 'plan', layer: 'L2' }],
+    [
+      { name: 'cook', layer: 'L1' },
+      { name: 'plan', layer: 'L2' },
+    ],
     { version: '1.0.0' },
   );
   assert.ok(fewSkills.description.includes('2-skill'), 'description reflects actual skill count');

package/compiler/__tests__/out-of-scope-format.test.js

@@ -0,0 +1,303 @@
+/**
+ * .out-of-scope/ KB format validation.
+ *
+ * Validates:
+ *   - Frontmatter parses as YAML
+ *   - Required fields present (concept, aliases, decision, rejected_at, rejected_by, prior_requests)
+ *   - decision == "rejected" (deferrals don't belong here)
+ *   - concept matches filename (slug rule)
+ *   - prior_requests has >=1 entry
+ *   - Slug rules: kebab-case, lowercase, max 40 chars
+ *
+ * Operates on test fixtures (no real .out-of-scope/ in this repo yet).
+ */
+
+import assert from 'node:assert';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, test } from 'node:test';
+
+// Minimal YAML frontmatter parser — we only need flat key:value + simple lists/objects.
+// Mirrors what ba and review-intake expect at runtime.
+function parseFrontmatter(text) {
+  const match = text.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const block = match[1];
+  const lines = block.split('\n');
+  const out = {};
+  let currentKey = null;
+  let currentList = null;
+  let currentObj = null;
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    if (line.startsWith('  - ')) {
+      // List item, or object-list item starting with `- key: value`
+      const inner = line.slice(4);
+      if (inner.includes(': ')) {
+        // First field of a new object in the list
+        currentObj = {};
+        const [k, v] = inner.split(/:\s+/);
+        currentObj[k.trim()] = stripQuotes(v.trim());
+        currentList.push(currentObj);
+      } else {
+        currentList.push(stripQuotes(inner.trim()));
+        currentObj = null;
+      }
+    } else if (line.startsWith('    ')) {
+      // Continuation field of the current object
+      if (currentObj && line.includes(': ')) {
+        const [k, v] = line.trim().split(/:\s+/);
+        currentObj[k.trim()] = stripQuotes(v.trim());
+      }
+    } else if (line.match(/^[a-z_]+:/)) {
+      const [key, ...rest] = line.split(':');
+      const value = rest.join(':').trim();
+      currentKey = key.trim();
+      currentObj = null;
+      if (value === '' || value === '[]') {
+        out[currentKey] = [];
+        currentList = out[currentKey];
+      } else if (value.startsWith('[') && value.endsWith(']')) {
+        out[currentKey] = value
+          .slice(1, -1)
+          .split(',')
+          .map((s) => stripQuotes(s.trim()))
+          .filter(Boolean);
+        currentList = null;
+      } else {
+        out[currentKey] = stripQuotes(value);
+        currentList = null;
+      }
+    }
+  }
+  return out;
+}
+
+function stripQuotes(s) {
+  if (!s) return s;
+  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+const REQUIRED_FIELDS = ['concept', 'aliases', 'decision', 'rejected_at', 'rejected_by', 'prior_requests'];
+const SLUG_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+
+function validateOutOfScope(filename, content) {
+  const issues = [];
+  const fm = parseFrontmatter(content);
+  if (!fm) return ['frontmatter missing or unparseable'];
+
+  for (const f of REQUIRED_FIELDS) {
+    if (!(f in fm) || fm[f] === undefined) issues.push(`missing field: ${f}`);
+  }
+
+  if (fm.decision && fm.decision !== 'rejected') {
+    issues.push(`decision must be "rejected" (got "${fm.decision}") — deferrals don't belong in .out-of-scope/`);
+  }
+
+  if (fm.concept) {
+    if (!SLUG_RE.test(fm.concept)) issues.push(`concept slug malformed: ${fm.concept}`);
+    if (fm.concept.length > 40) issues.push(`concept slug too long (>40 chars): ${fm.concept}`);
+    const expected = path.basename(filename, '.md');
+    if (fm.concept !== expected) {
+      issues.push(`concept "${fm.concept}" does not match filename "${expected}"`);
+    }
+  }
+
+  if (fm.rejected_at && !ISO_DATE_RE.test(fm.rejected_at)) {
+    issues.push(`rejected_at must be ISO date YYYY-MM-DD (got "${fm.rejected_at}")`);
+  }
+
+  if (Array.isArray(fm.prior_requests) && fm.prior_requests.length === 0) {
+    issues.push('prior_requests must have >=1 entry');
+  }
+
+  return issues;
+}
+
+// --- Tests ---
+
+describe('out-of-scope/ KB format', () => {
+  let tmpDir;
+
+  test('valid file passes', () => {
+    tmpDir = mkdtempSync(path.join(os.tmpdir(), 'rune-oos-'));
+    const file = path.join(tmpDir, 'dark-mode.md');
+    const content = `---
+concept: dark-mode
+aliases: [night-theme, dark-theme]
+decision: rejected
+rejected_at: 2026-04-27
+rejected_by: review-intake
+priority_to_revisit: low
+prior_requests:
+  - id: gh-issue-42
+    summary: Add dark mode support
+    closed_at: 2025-08-01
+revisit_if:
+  - "team adds front-end engineer"
+---
+
+# Dark Mode
+
+Body content.
+`;
+    writeFileSync(file, content);
+    const issues = validateOutOfScope(file, content);
+    assert.deepStrictEqual(issues, []);
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('rejects file with decision=deferred', () => {
+    const content = `---
+concept: dark-mode
+aliases: [night-theme]
+decision: deferred
+rejected_at: 2026-04-27
+rejected_by: ba
+prior_requests:
+  - id: gh-issue-42
+    summary: x
+    closed_at: 2025-08-01
+---
+
+body
+`;
+    const issues = validateOutOfScope('dark-mode.md', content);
+    assert.ok(
+      issues.some((i) => i.includes('decision must be "rejected"')),
+      'should reject decision=deferred',
+    );
+  });
+
+  test('rejects mismatched filename and concept', () => {
+    const content = `---
+concept: foo-bar
+aliases: []
+decision: rejected
+rejected_at: 2026-04-27
+rejected_by: ba
+prior_requests:
+  - id: i
+    summary: s
+    closed_at: 2025-08-01
+---
+
+body
+`;
+    const issues = validateOutOfScope('different-name.md', content);
+    assert.ok(
+      issues.some((i) => i.includes('does not match filename')),
+      'should flag filename/concept mismatch',
+    );
+  });
+
+  test('rejects empty prior_requests', () => {
+    const content = `---
+concept: dark-mode
+aliases: []
+decision: rejected
+rejected_at: 2026-04-27
+rejected_by: ba
+prior_requests: []
+---
+
+body
+`;
+    const issues = validateOutOfScope('dark-mode.md', content);
+    assert.ok(
+      issues.some((i) => i.includes('prior_requests must have >=1 entry')),
+      'should require prior_requests',
+    );
+  });
+
+  test('rejects malformed slug', () => {
+    const content = `---
+concept: Dark_Mode
+aliases: []
+decision: rejected
+rejected_at: 2026-04-27
+rejected_by: ba
+prior_requests:
+  - id: i
+    summary: s
+    closed_at: 2025-08-01
+---
+
+body
+`;
+    const issues = validateOutOfScope('Dark_Mode.md', content);
+    assert.ok(
+      issues.some((i) => i.includes('concept slug malformed')),
+      'should reject non-kebab-case slug',
+    );
+  });
+
+  test('rejects slug longer than 40 chars', () => {
+    const longSlug = 'a-very-long-concept-name-that-exceeds-the-forty-char-cap';
+    const content = `---
+concept: ${longSlug}
+aliases: []
+decision: rejected
+rejected_at: 2026-04-27
+rejected_by: ba
+prior_requests:
+  - id: i
+    summary: s
+    closed_at: 2025-08-01
+---
+
+body
+`;
+    const issues = validateOutOfScope(`${longSlug}.md`, content);
+    assert.ok(
+      issues.some((i) => i.includes('too long')),
+      'should reject overlong slug',
+    );
+  });
+
+  test('rejects malformed rejected_at date', () => {
+    const content = `---
+concept: dark-mode
+aliases: []
+decision: rejected
+rejected_at: yesterday
+rejected_by: ba
+prior_requests:
+  - id: i
+    summary: s
+    closed_at: 2025-08-01
+---
+
+body
+`;
+    const issues = validateOutOfScope('dark-mode.md', content);
+    assert.ok(
+      issues.some((i) => i.includes('ISO date')),
+      'should reject non-ISO date',
+    );
+  });
+
+  test('rejects file missing required fields', () => {
+    const content = `---
+concept: dark-mode
+---
+
+body
+`;
+    const issues = validateOutOfScope('dark-mode.md', content);
+    assert.ok(issues.length >= 4, `expected multiple missing-field errors, got ${issues.length}`);
+  });
+});
+
+describe('signal name validity', () => {
+  test('outofscope.match conforms to signal naming pattern', () => {
+    const SIGNAL_PATTERN = /^[a-z][a-z0-9]*(\.[a-z][a-z0-9]*)+$/;
+    assert.ok(SIGNAL_PATTERN.test('outofscope.match'));
+  });
+});