harness-everything 0.2.2 → 0.4.0

package/plugins/harness-everything/skills/self-evolve/scripts/persist-memory.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+let getWorkspaceRoot;
+try {
+  ({ getWorkspaceRoot } = require('../../scripts/lib/workspace'));
+} catch (err) {
+  getWorkspaceRoot = () => null;
+}
+
+// NOTE: this script ships standalone - it is copied whole into every install
+// target. When the canonical workspace resolver is not present, persistence
+// fails closed rather than guessing a project root (issue #42).
+
+const SECRET_PATTERNS = [
+  ['github-token', /\bgh[pousr]_[A-Za-z0-9]{20,}\b/],
+  ['openai-key', /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/],
+  ['aws-access-key', /\bAKIA[0-9A-Z]{16}\b/],
+  ['private-key', /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/],
+  ['jwt', /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/],
+  ['credential-assignment', /\b(?:api[_-]?key|access[_-]?token|auth[_-]?token|password|passwd|secret)\s*[:=]\s*["']?[A-Za-z0-9_./+=:-]{8,}/i],
+];
+
+const INJECTION_PATTERNS = [
+  ['ignore-prior-instructions', /\bignore\s+(?:all\s+)?(?:previous|prior|above)\s+(?:instructions|messages|rules)\b/i],
+  ['replace-instructions', /\b(?:follow|obey)\s+(?:these|the following)\s+instructions\s+instead\b/i],
+  ['role-override', /\byou\s+are\s+now\b/i],
+  ['instruction-override', /\boverride\s+(?:the\s+)?(?:system|developer|safety|previous|prior)\s+(?:instructions|message|prompt|rules)\b/i],
+  ['system-prompt-exfiltration', /\b(?:reveal|print|show|expose)\s+(?:the\s+)?(?:system|developer)\s+prompt\b/i],
+  ['role-token', /<\|(?:system|developer|assistant)\|>/i],
+  ['jailbreak-marker', /\b(?:jailbreak|prompt[- ]injection)\b/i],
+];
+
+function parseArgs(argv) {
+  let memoryText = null;
+  let source = 'manual-unspecified';
+  for (let index = 0; index < argv.length; index++) {
+    const token = argv[index];
+    if (token === '--help' || token === '-h') return { help: true, memoryText: null, source };
+    if (token === '--source') {
+      if (index + 1 >= argv.length) throw new Error('--source requires a value');
+      source = argv[++index];
+      continue;
+    }
+    if (token.startsWith('--source=')) {
+      source = token.slice('--source='.length);
+      continue;
+    }
+    if (token.startsWith('-')) throw new Error(`unknown option: ${token}`);
+    if (memoryText !== null) throw new Error('exactly one memory rule positional argument is allowed');
+    memoryText = token;
+  }
+  return { help: false, memoryText, source };
+}
+
+function normalizeSource(value) {
+  const source = String(value || 'manual-unspecified').trim();
+  if (!source) return 'manual-unspecified';
+  if (/[\r\n\0]/.test(source)) throw new Error('source provenance must be one line');
+  if (source.length > 240) throw new Error('source provenance exceeds 240 characters');
+  const secretReasons = detectReasonCodes(source, SECRET_PATTERNS);
+  if (secretReasons.length > 0) throw new Error(`source provenance rejected by secret screening: ${secretReasons.join(', ')}`);
+  return source;
+}
+
+function detectReasonCodes(text, patterns) {
+  const reasons = [];
+  for (const [reasonCode, pattern] of patterns) {
+    if (pattern.test(text)) reasons.push(reasonCode);
+  }
+  return reasons;
+}
+
+function screenMemoryForPersistence(text) {
+  const value = String(text || '');
+  const secretReasonCodes = detectReasonCodes(value, SECRET_PATTERNS);
+  const injectionReasonCodes = detectReasonCodes(value, INJECTION_PATTERNS);
+  return {
+    allowed: secretReasonCodes.length === 0 && injectionReasonCodes.length === 0,
+    secretReasonCodes,
+    injectionReasonCodes,
+  };
+}
+
+function calculateSimilarity(text1, text2) {
+  const words1 = text1.toLowerCase().split(/\s+/);
+  const words2 = text2.toLowerCase().split(/\s+/);
+  const set1 = new Set(words1);
+  const set2 = new Set(words2);
+  let intersection = 0;
+  for (const word of set1) {
+    if (set2.has(word)) intersection++;
+  }
+  const union = set1.size + set2.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+
+function scoreRuleQuality(ruleText, existingRules = []) {
+  let score = 0;
+  if (/\.\w{2,4}/.test(ruleText)) score += 2;
+  if (/Error|Exception|Warning|錯誤|異常|警告/.test(ruleText)) score += 2;
+  if (/\b(test|lint|build|verify|check|測試|檢查)\b/i.test(ruleText)) score += 1;
+  if (/^(Always|Never|Check|Verify|Prefer|Avoid|Use|不要|總是|檢查|驗證|避免|使用)/i.test(ruleText)) score += 3;
+  if (/^(should|must|will|needs? to|ought|應該|必須|需要)/i.test(ruleText)) score += 2;
+  const isDuplicate = existingRules.some(existing => calculateSimilarity(ruleText, existing) > 0.7);
+  if (!isDuplicate) score += 3;
+  if (ruleText.length > 20 && ruleText.length < 200) score += 1;
+  return Math.min(score, 10);
+}
+
+function extractExistingRules(rulesFile) {
+  if (!fs.existsSync(rulesFile)) return [];
+  try {
+    const content = fs.readFileSync(rulesFile, 'utf8');
+    const ruleMatches = content.match(/^- .+$/gm) || [];
+    return ruleMatches.map(rule => rule.substring(2));
+  } catch (err) {
+    return [];
+  }
+}
+
+function contentHash(text) {
+  return crypto.createHash('sha256').update(String(text), 'utf8').digest('hex');
+}
+
+function persistMemory({ memoryText, source = 'manual-unspecified' }) {
+  const ruleText = String(memoryText || '').trim();
+  if (!ruleText) return { ok: false, exitCode: 1, message: 'memory rule is required' };
+
+  const screening = screenMemoryForPersistence(ruleText);
+  if (!screening.allowed) {
+    const reasons = [...screening.secretReasonCodes, ...screening.injectionReasonCodes];
+    return {
+      ok: false,
+      exitCode: 2,
+      screening,
+      message: `memory rejected by persistence screening: ${reasons.join(', ')}`,
+    };
+  }
+
+  let provenance;
+  try {
+    provenance = normalizeSource(source);
+  } catch (err) {
+    return { ok: false, exitCode: 2, screening, message: err.message };
+  }
+
+  const currentDir = getWorkspaceRoot();
+  if (!currentDir) {
+    return {
+      ok: false,
+      exitCode: 1,
+      screening,
+      message: 'Cannot persist project memory without a resolved git workspace.',
+    };
+  }
+
+  const memoryDir = path.join(currentDir, 'memories', 'repo');
+  const rulesFile = path.join(memoryDir, 'RULES.md');
+  const existingRules = extractExistingRules(rulesFile);
+  const qualityScore = scoreRuleQuality(ruleText, existingRules);
+  if (qualityScore < 5) {
+    return {
+      ok: false,
+      exitCode: 1,
+      screening,
+      qualityScore,
+      message: `Rule rejected - score ${qualityScore}/10 (minimum 5 required)`,
+    };
+  }
+
+  const isDuplicate = existingRules.some(existing => calculateSimilarity(ruleText, existing) > 0.7);
+  if (isDuplicate) {
+    return {
+      ok: false,
+      exitCode: 1,
+      screening,
+      qualityScore,
+      message: 'Rule rejected - similar rule already exists',
+    };
+  }
+
+  fs.mkdirSync(memoryDir, { recursive: true });
+  const timestamp = new Date().toISOString().split('T')[0];
+  const hash = contentHash(ruleText);
+  const formattedMemory = [
+    '',
+    `## [${timestamp}] Self-Evolution Insight (Quality: ${qualityScore}/10)`,
+    `Source: ${provenance}`,
+    `Content-SHA256: ${hash}`,
+    'Screening: secret=clear; prompt-injection=clear',
+    `- ${ruleText}`,
+    '',
+  ].join('\n');
+  fs.appendFileSync(rulesFile, formattedMemory, 'utf8');
+  return {
+    ok: true,
+    exitCode: 0,
+    rulesFile,
+    qualityScore,
+    source: provenance,
+    contentSha256: hash,
+    screening,
+  };
+}
+
+function printHelp() {
+  console.log(`Append a short defensive rule to memories/repo/RULES.md.
+
+Usage: node persist-memory.js "<insight to remember>" [--source <provenance>]
+
+The rule must be universal and actionable. --source records where the lesson came
+from (for example issue-85, verifier-stage-3, or manual-review); when omitted the
+source is recorded as manual-unspecified.
+
+Persistence gates:
+- secret-like tokens and credential material are rejected before any write
+- prompt-injection-shaped instructions are rejected before any write
+- source provenance is recorded with a SHA-256 content fingerprint
+- minimum quality score of 5/10 and similarity deduplication still apply`);
+}
+
+if (require.main === module) {
+  let parsed;
+  try {
+    parsed = parseArgs(process.argv.slice(2));
+  } catch (err) {
+    console.error(`[self-evolve] ${err.message}`);
+    process.exit(1);
+  }
+
+  if (parsed.help) {
+    printHelp();
+    process.exit(0);
+  }
+  if (!parsed.memoryText) {
+    console.error('Usage: node persist-memory.js "<insight to remember>" [--source <provenance>]');
+    process.exit(1);
+  }
+
+  try {
+    const result = persistMemory(parsed);
+    if (!result.ok) {
+      const prefix = result.exitCode === 2 ? '[Persistence Screening]' : '[Quality Gate]';
+      console.error(`${prefix} ${result.message}`);
+      if (result.qualityScore !== undefined && result.qualityScore < 5) {
+        console.error('Suggestions to improve:');
+        console.error('- Be more specific (mention file types, error patterns)');
+        console.error('- Start with action verbs (Always, Never, Check, Verify)');
+        console.error('- Ensure the rule is actionable and not already captured');
+      }
+      process.exit(result.exitCode);
+    }
+    console.log(`[Success] Memory persisted to ${result.rulesFile} (Quality: ${result.qualityScore}/10, Source: ${result.source})`);
+  } catch (err) {
+    console.error(`[Error] Failed to write memory: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  calculateSimilarity,
+  contentHash,
+  extractExistingRules,
+  parseArgs,
+  persistMemory,
+  scoreRuleQuality,
+  screenMemoryForPersistence,
+};

package/plugins/harness-everything/skills/self-evolve/scripts/register-dynamic-skill.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+let getWorkspaceRoot;
+try {
+  ({ getWorkspaceRoot } = require('../../scripts/lib/workspace'));
+} catch (err) {
+  getWorkspaceRoot = () => null;
+}
+
+const workspaceRoot = getWorkspaceRoot();
+if (!workspaceRoot) {
+  console.error('[self-evolve] Cannot register a dynamic skill without a resolved git workspace.');
+  process.exit(1);
+}
+
+function loadManifestHelper() {
+  const candidates = [
+    path.join(__dirname, '../../scripts/lib/manifest'),
+    path.join(__dirname, '../scripts/lib/manifest'),
+    path.join(__dirname, '../../../scripts/lib/manifest'),
+    path.join(workspaceRoot, 'scripts/lib/manifest'),
+    path.join(workspaceRoot, 'harness-everything/scripts/lib/manifest'),
+  ];
+  for (const cand of candidates) {
+    try {
+      if (fs.existsSync(cand + '.js') || fs.existsSync(cand)) {
+        return require(cand);
+      }
+    } catch (e) {}
+  }
+  throw new Error('[register-dynamic-skill] Failed to locate manifest helper module (scripts/lib/manifest)');
+}
+
+const { getManifestPath, readManifest, writeManifest, recordGeneratedSkill } = loadManifestHelper();
+
+// Find user home folder
+const userHome = process.env.HOME || process.env.USERPROFILE || '';
+
+// List of all possible manifest.json home paths
+const manifestHomes = [
+  path.join(workspaceRoot, '.claude'),
+  path.join(workspaceRoot, '.cursor'),
+  path.join(workspaceRoot, '.github'),
+  path.join(workspaceRoot, '.codex'),
+  path.join(workspaceRoot, '.continue'),
+  path.join(userHome, '.agents'),
+  path.join(userHome, '.claude')
+];
+
+// Helper to parse simple YAML frontmatter without external dependencies
+function parseFrontmatter(content) {
+  const lines = content.split(/\r?\n/);
+  const fm = {};
+  let inFM = false;
+  const fmLines = [];
+  
+  for (const line of lines) {
+    if (line.trim() === '---') {
+      if (!inFM) {
+        inFM = true;
+        continue;
+      } else {
+        break;
+      }
+    }
+    if (inFM) {
+      fmLines.push(line);
+    }
+  }
+
+  let currentKey = null;
+  for (const line of fmLines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    // Check if indent level is substantial (nested list or object)
+    const indent = line.search(/\S/);
+    
+    if (indent === 0) {
+      const match = line.match(/^([a-zA-Z0-9_-]+)\s*:\s*(.*)$/);
+      if (match) {
+        const key = match[1];
+        const val = match[2].trim();
+        
+        let cleanVal = val;
+        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+          cleanVal = val.slice(1, -1);
+        }
+        
+        if (val.startsWith('[') && val.endsWith(']')) {
+          cleanVal = val.slice(1, -1).split(',').map(s => s.trim().replace(/^['"]|['"]$/g, ''));
+        }
+        
+        fm[key] = cleanVal;
+        currentKey = key;
+      }
+    } else if (indent > 0 && currentKey) {
+      // Handle nested properties or array items
+      if (trimmed.startsWith('- ')) {
+        if (!Array.isArray(fm[currentKey])) {
+          fm[currentKey] = [];
+        }
+        fm[currentKey].push(trimmed.slice(2).trim().replace(/^['"]|['"]$/g, ''));
+      } else {
+        const childMatch = trimmed.match(/^([a-zA-Z0-9_-]+)\s*:\s*(.*)$/);
+        if (childMatch) {
+          if (typeof fm[currentKey] !== 'object' || Array.isArray(fm[currentKey])) {
+            fm[currentKey] = {};
+          }
+          const childKey = childMatch[1];
+          const childVal = childMatch[2].trim().replace(/^['"]|['"]$/g, '');
+          fm[currentKey][childKey] = childVal;
+        }
+      }
+    }
+  }
+  return fm;
+}
+
+function processSkillDir(skillDirPath) {
+  const skillFile = path.join(skillDirPath, 'SKILL.md');
+  if (!fs.existsSync(skillFile)) {
+    return null;
+  }
+
+  const content = fs.readFileSync(skillFile, 'utf8');
+  const fm = parseFrontmatter(content);
+  
+  const skillId = fm.name || path.basename(skillDirPath);
+  const description = fm.description || 'No description provided';
+  
+  // Extract custom triggers/tags if defined, or infer them from keywords
+  let triggers = [];
+  if (fm.triggers) {
+    triggers = Array.isArray(fm.triggers) ? fm.triggers : [fm.triggers];
+  } else if (fm.metadata && fm.metadata.triggers) {
+    triggers = Array.isArray(fm.metadata.triggers) ? fm.metadata.triggers : [fm.metadata.triggers];
+  } else {
+    // Fallback only - explicit `triggers:` frontmatter (mandated by
+    // skill-creator/SKILL.md §4) should make this branch rare. Kept
+    // deliberately conservative: only the skill name plus the description's
+    // first sentence (not the whole prose block), a longer stopword list,
+    // and a length-5+ floor, so a generic skill description doesn't spam
+    // tier-router.js with broad words that fire on unrelated prompts.
+    const firstSentence = description.split(/[.!?]/)[0];
+    const STOPWORDS = new Set([
+      'with', 'from', 'this', 'that', 'your', 'about', 'some', 'than', 'then',
+      'prevent', 'resolved', 'skill', 'agent', 'using', 'which', 'these',
+      'those', 'their', 'there', 'where', 'when', 'while', 'after', 'before',
+      'again', 'other', 'every', 'being', 'would', 'could', 'should', 'still',
+      'first', 'never', 'always', 'ensure', 'provide', 'provided'
+    ]);
+    const words = (skillId + ' ' + firstSentence)
+      .toLowerCase()
+      .replace(/[^\w\s-]/g, ' ')
+      .split(/\s+/)
+      .filter(w => w.length >= 5 && !STOPWORDS.has(w));
+    triggers = [...new Set(words)].slice(0, 8);
+  }
+
+  return {
+    id: skillId,
+    dirPath: skillDirPath,
+    description,
+    triggers,
+    metadata: fm.metadata || {}
+  };
+}
+
+function register() {
+  const arg = process.argv[2];
+
+  if (arg === '--help' || arg === '-h') {
+    console.log(`Register self-evolve dynamic skills into every detected platform manifest.json.
+
+Usage:
+  node register-dynamic-skill.js              Scan .claude/harness-everything/skills/generated/ and register every skill found there.
+  node register-dynamic-skill.js <name>        Register only the skill folder named <name> under skills/generated/.
+  node register-dynamic-skill.js <path>        Register the skill folder at this literal path instead.
+
+Each skill folder needs a SKILL.md with 'name' and 'description' frontmatter (plus
+'triggers' - if omitted, triggers are inferred from the name and description, which
+is a conservative fallback, not a substitute for setting them explicitly). Writes to
+every already-bootstrapped platform's manifest.json (.claude/, .cursor/, .github/,
+.codex/, .continue/, plus the user-home ~/.agents and ~/.claude homes).`);
+    process.exit(0);
+  }
+
+  const generatedBaseDir = path.join(workspaceRoot, '.claude', 'harness-everything', 'skills', 'generated');
+  
+  let skillsToRegister = [];
+
+  if (arg) {
+    // Scenario A: Register specific skill ID or path
+    let skillPath = arg;
+    if (!fs.existsSync(skillPath)) {
+      skillPath = path.join(generatedBaseDir, arg);
+    }
+    if (fs.existsSync(skillPath)) {
+      const info = processSkillDir(skillPath);
+      if (info) skillsToRegister.push(info);
+    } else {
+      console.error(`[Error] Dynamic skill folder not found: ${arg}`);
+      process.exit(1);
+    }
+  } else {
+    // Scenario B: Scan whole generated folder
+    if (fs.existsSync(generatedBaseDir)) {
+      const subdirs = fs.readdirSync(generatedBaseDir, { withFileTypes: true });
+      for (const entry of subdirs) {
+        if (entry.isDirectory()) {
+          const dirPath = path.join(generatedBaseDir, entry.name);
+          const info = processSkillDir(dirPath);
+          if (info) skillsToRegister.push(info);
+        }
+      }
+    }
+  }
+
+  if (skillsToRegister.length === 0) {
+    console.log('[Info] No self-evolved dynamic skills found to register.');
+    return;
+  }
+
+  // Write to all detected manifests (auto-creating target directories if in workspace)
+  let count = 0;
+  for (const home of manifestHomes) {
+    const manifestPath = getManifestPath(home);
+    const parentDir = path.dirname(manifestPath);
+    const isRepoHome = home.startsWith(workspaceRoot);
+    if (fs.existsSync(parentDir) || isRepoHome) {
+      fs.mkdirSync(parentDir, { recursive: true });
+      for (const skill of skillsToRegister) {
+        recordGeneratedSkill(manifestPath, skill.id, skill.dirPath, skill.description, skill.triggers);
+      }
+      console.log(`[Success] Registered ${skillsToRegister.length} skill(s) to ${manifestPath}`);
+      count++;
+    }
+  }
+
+  if (count === 0) {
+    // Fallback: If no manifest path's directory existed, write to at least the standard home path
+    const fallbackHome = path.join(userHome, '.agents');
+    const manifestPath = getManifestPath(fallbackHome);
+    for (const skill of skillsToRegister) {
+      recordGeneratedSkill(manifestPath, skill.id, skill.dirPath, skill.description, skill.triggers);
+    }
+    console.log(`[Success] Registered ${skillsToRegister.length} skill(s) to fallback manifest ${manifestPath}`);
+  }
+}
+
+register();

package/plugins/harness-everything/skills/self-evolve/scripts/self-regression.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * Harness Self-Regression Test Suite.
+ *
+ * This is the free, deterministic gate. Model sessions remain on-demand;
+ * their results must not be confused with a local tracker simulation.
+ */
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const projectRoot = path.resolve(__dirname, '..', '..');
+let hasErrors = false;
+
+let pkgName = null;
+try {
+  pkgName = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8')).name;
+} catch (e) {}
+if (pkgName !== 'harness-everything') {
+  console.log('self-regression.js validates the Harness-everything repo\'s own CI; this workspace is not that repo, so there is nothing to check here. Skipping.');
+  process.exit(0);
+}
+
+console.log('=================================================');
+console.log('     Harness OS - Self-Regression Test Suite     ');
+console.log('=================================================');
+
+function runNode(label, script, args = [], options = {}) {
+  const result = spawnSync('node', [script, ...args], {
+    cwd: projectRoot,
+    stdio: 'inherit',
+    ...options,
+  });
+  if (result.status !== 0) {
+    console.error(`  FAIL ${label}`);
+    hasErrors = true;
+  } else {
+    console.log(`  PASS ${label}`);
+  }
+  return result;
+}
+
+console.log('\n[Phase 1] Static Syntax Check...');
+const foldersToScan = ['harness-everything', 'hooks', 'environment-detection', 'self-evolve', 'ci', 'eval-harness', 'scripts', 'bin', 'to-spec', 'to-tickets', 'find-skills', 'fable-mode', 'multi-agent-workspace'];
+const jsFiles = [];
+function walkDir(dir) {
+  if (!fs.existsSync(dir)) return;
+  for (const file of fs.readdirSync(dir)) {
+    const filePath = path.join(dir, file);
+    if (fs.statSync(filePath).isDirectory()) walkDir(filePath);
+    else if (filePath.endsWith('.js')) jsFiles.push(filePath);
+  }
+}
+for (const folder of foldersToScan) walkDir(path.join(projectRoot, folder));
+for (const file of jsFiles) {
+  const check = spawnSync('node', ['--check', file]);
+  if (check.status !== 0) {
+    console.error(`  FAIL syntax: ${path.relative(projectRoot, file)}`);
+    console.error(check.stderr.toString().trim());
+    hasErrors = true;
+  }
+}
+console.log(`  PASS syntax: ${jsFiles.length} JavaScript file(s)`);
+
+console.log('\n[Phase 1b] CLI Command Smoke Test...');
+const cliPath = path.join(projectRoot, 'bin', 'cli.js');
+const nextCheck = spawnSync('node', [cliPath, 'next', 'add a new login endpoint with tests'], { cwd: projectRoot });
+if (nextCheck.status !== 0 || !nextCheck.stdout.toString().includes('RECOMMENDED TIER')) {
+  console.error('  FAIL `harness next` did not produce a routing recommendation.');
+  hasErrors = true;
+} else if (!nextCheck.stdout.toString().includes('REQUIRED HARNESS INVARIANTS')) {
+  console.error('  FAIL `harness next` did not establish the invariant-first kernel contract.');
+  hasErrors = true;
+} else console.log('  PASS `harness next` produced routing + invariant contract.');
+const verifyCheck = spawnSync('node', [cliPath, 'verify'], {
+  cwd: projectRoot,
+  env: { ...process.env, HARNESS_SKIP_PROJECT_CHECKS: '1' },
+});
+if (verifyCheck.status !== 0) {
+  console.error('  FAIL `harness verify` exited non-zero on a skipped check.');
+  hasErrors = true;
+} else console.log('  PASS `harness verify` exited 0 on a skipped check.');
+
+console.log('\n[Phase 2] Routing Verification Check...');
+runNode('routing matrix', path.join(projectRoot, 'ci', 'runner.js'));
+runNode('skill route coverage', path.join(projectRoot, 'ci', 'skill-routing-check.js'));
+runNode('invariant-first routing contract', path.join(projectRoot, 'ci', 'invariant-routing.test.js'));
+runNode('workflow-plan structured contract', path.join(projectRoot, 'ci', 'router-workflow-plan.test.js'));
+runNode('explicit parallel safety contract', path.join(projectRoot, 'ci', 'router-phase2-safety.test.js'));
+runNode('workflow-plan consumers', path.join(projectRoot, 'ci', 'workflow-plan-consumers.test.js'));
+runNode('workflow-plan consumer edge contracts', path.join(projectRoot, 'ci', 'workflow-plan-consumers-edge.test.js'));
+runNode('phase 4 ensemble/memory evidence', path.join(projectRoot, 'ci', 'phase4-ensemble-memory.test.js'));
+runNode('phase 5 pre-action gate', path.join(projectRoot, 'ci', 'action-gate.test.js'));
+runNode('phase 5 platform evidence boundary', path.join(projectRoot, 'ci', 'action-gate-platform-doc.test.js'));
+runNode('issue #99 runtime correctness', path.join(projectRoot, 'ci', 'issue99-runtime.test.js'));
+
+console.log('\n[Phase 3] Skill Reference and Behavioral Case Checks...');
+runNode('skill reference check', path.join(projectRoot, 'ci', 'reference-check.js'));
+runNode('behavioral case validation', path.join(projectRoot, 'behavioral-evals', 'run.js'), ['validate']);
+console.log('\n[Phase 3b] Fable Model Mode Contract Tests...');
+const fableModeTestPath = path.join(projectRoot, 'ci', 'fable-mode-test.js');
+if (fs.existsSync(fableModeTestPath)) {
+  const fableModeCheck = spawnSync('node', [fableModeTestPath], { stdio: 'inherit', cwd: projectRoot });
+  if (fableModeCheck.status !== 0) {
+    console.error("\n  ❌ Fable model mode contract suite failed!");
+    hasErrors = true;
+  } else {
+    console.log("\n  ✅ Fable model mode contract suite 100% Passed!");
+  }
+} else {
+  console.warn("  ⚠️  ci/fable-mode-test.js not found. Skipping Phase 3.");
+}
+
+console.log('\n[Phase 4] Mechanism Test Suite (Claude Code hooks)...');
+runNode('mechanism suite', path.join(projectRoot, 'ci', 'mechanism-test.js'));
+
+console.log('\n=================================================');
+if (hasErrors) {
+  console.error(' FAIL: self-regression found one or more problems.');
+  console.log('=================================================');
+  process.exit(1);
+}
+console.log(' PASS: all deterministic self-regression checks passed.');
+console.log('=================================================');