mindforge-cc 1.0.0

package/tests/governance.test.js

@@ -0,0 +1,130 @@
+/**
+ * MindForge Day 4 — Governance Tests
+ * Run: node tests/governance.test.js
+ */
+
+const fs = require('fs');
+const assert = require('assert');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ✅ ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  ❌ ${name}`);
+    console.error(`     ${err.message}`);
+    failed++;
+  }
+}
+
+function read(file) {
+  return fs.readFileSync(file, 'utf8');
+}
+
+function classifyChange({ files, diff, recentHighSeverityFinding = false }) {
+  const fileSignals = /(auth\/|security\/|payment\/|billing\/|privacy\/|crypto\/|secrets\/|login\.ts|logout\.ts|token\.ts|password\.ts|credentials\.ts|session\.ts|oauth\.ts|jwt\.ts|hash\.ts|encrypt\.ts|stripe\.ts|payment\.ts|billing\.ts|pii\.ts|consent\.ts)/;
+  const codeSignals = /(bcrypt|argon2|jwt\.sign|jwt\.verify|jose\.sign|jose\.verify|stripe\.|paypal\.|createCipheriv|createDecipheriv|crypto\.subtle|hashPassword|verifyPassword|encrypt\(|decrypt\(|role.*permission|hasPermission|SET ROLE|GRANT)/;
+
+  if (files.some(file => fileSignals.test(file))) return 3;
+  if (codeSignals.test(diff)) return 3;
+  if (recentHighSeverityFinding) return 3;
+  if (files.length > 10) return 2;
+  return 1;
+}
+
+console.log('\nMindForge Day 4 — Governance Tests\n');
+
+console.log('Governance files:');
+
+[
+  '.mindforge/governance/change-classifier.md',
+  '.mindforge/governance/approval-workflow.md',
+  '.mindforge/governance/compliance-gates.md',
+  '.mindforge/governance/GOVERNANCE-CONFIG.md',
+  '.mindforge/team/multi-handoff.md',
+  '.mindforge/team/session-merger.md',
+  'docs/governance-guide.md',
+].forEach(file => {
+  test(`${file} exists`, () => assert.ok(fs.existsSync(file), `Missing ${file}`));
+});
+
+console.log('\nClassifier hardening:');
+
+test('tier 3 triggers on code pattern even in helper.ts', () => {
+  const tier = classifyChange({
+    files: ['src/utils/helper.ts'],
+    diff: '+ const token = jwt.sign(payload, secret);',
+  });
+  assert.strictEqual(tier, 3);
+});
+
+test('tier 3 triggers on audit-history escalation', () => {
+  const tier = classifyChange({
+    files: ['src/utils/helpers.ts'],
+    diff: '+ export const noop = true;',
+    recentHighSeverityFinding: true,
+  });
+  assert.strictEqual(tier, 3);
+});
+
+test('change classifier documents trigger points and code-content scanning', () => {
+  const content = read('.mindforge/governance/change-classifier.md');
+  assert.ok(content.includes('Before each plan executes'), 'Missing plan execution trigger');
+  assert.ok(content.includes('Code content patterns'), 'Missing code-content scanning section');
+  assert.ok(content.includes('jwt.sign'), 'Missing concrete Tier 3 code pattern');
+});
+
+console.log('\nApproval workflow and emergency handling:');
+
+test('approval workflow documents pending-only listing and rejection context carry-forward', () => {
+  const approve = read('.claude/commands/mindforge/approve.md');
+  const workflow = read('.mindforge/governance/approval-workflow.md');
+  assert.ok(approve.includes('status: pending'), 'Missing pending-only listing rule');
+  assert.ok(workflow.includes('rejection reason'), 'Missing rejection-reason carry-forward');
+});
+
+test('approve command requires explicit emergency flag and EMERGENCY_APPROVERS config', () => {
+  const approve = read('.claude/commands/mindforge/approve.md');
+  const config = read('.mindforge/org/integrations/INTEGRATIONS-CONFIG.md');
+  assert.ok(approve.includes('--emergency'), 'Missing emergency flag requirement');
+  assert.ok(config.includes('EMERGENCY_APPROVERS='), 'Missing EMERGENCY_APPROVERS');
+});
+
+test('approval workflow documents identity assurance limitation', () => {
+  const content = read('.mindforge/governance/approval-workflow.md');
+  assert.ok(content.includes('spoofable'), 'Missing identity limitation acknowledgement');
+  assert.ok(content.includes('IdP'), 'Missing stronger identity recommendation');
+});
+
+console.log('\nCompliance and team coordination:');
+
+test('gdpr gate runs independently of skill loading and checks retention policy', () => {
+  const content = read('.mindforge/governance/compliance-gates.md');
+  assert.ok(content.includes('independently of skill loading'), 'Missing skill-independent gate');
+  assert.ok(content.includes('retention'), 'Missing retention requirement');
+});
+
+test('multi-developer handoff documents stale detection after 4 hours', () => {
+  const content = read('.mindforge/team/multi-handoff.md');
+  assert.ok(content.includes('older than 4 hours'), 'Missing stale detection threshold');
+});
+
+test('session merger requires AUDIT entries to be committed with task commits', () => {
+  const content = read('.mindforge/team/session-merger.md');
+  assert.ok(content.includes('AUDIT'), 'Missing AUDIT merge guidance');
+  assert.ok(content.includes('committed'), 'Missing committed AUDIT guidance');
+});
+
+console.log(`\n${'─'.repeat(50)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+
+if (failed > 0) {
+  console.error(`\n❌ ${failed} test(s) failed.\n`);
+  process.exit(1);
+} else {
+  console.log('\n✅ All governance tests passed.\n');
+}

package/tests/install.test.js

@@ -0,0 +1,209 @@
+/**
+ * MindForge installer smoke tests
+ * Run: node tests/install.test.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ✅ ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  ❌ ${name}`);
+    console.error(`     ${err.message}`);
+    failed++;
+  }
+}
+
+console.log('\nMindForge Day 1 — Structural Integrity Tests\n');
+
+// ── Directory structure tests ─────────────────────────────────────────────────
+console.log('Directories:');
+const dirs = [
+  '.claude/commands/mindforge',
+  '.agent/mindforge',
+  '.mindforge/personas',
+  '.mindforge/integrations',
+  '.mindforge/governance',
+  '.mindforge/team',
+  '.mindforge/org/integrations',
+  '.mindforge/skills/security-review',
+  '.mindforge/skills/code-quality',
+  '.mindforge/skills/api-design',
+  '.mindforge/skills/testing-standards',
+  '.mindforge/skills/documentation',
+  '.mindforge/org',
+  '.planning/decisions',
+  'bin',
+  'docs',
+  'tests',
+  '.planning/audit-archive',
+  '.planning/approvals',
+  '.planning/milestones',
+];
+dirs.forEach(d => test(d, () => assert.ok(fs.existsSync(d), `Missing: ${d}`)));
+
+// ── Required files tests ──────────────────────────────────────────────────────
+console.log('\nRequired files:');
+const files = [
+  '.claude/CLAUDE.md',
+  '.agent/CLAUDE.md',
+  '.claude/commands/mindforge/help.md',
+  '.claude/commands/mindforge/init-project.md',
+  '.claude/commands/mindforge/plan-phase.md',
+  '.claude/commands/mindforge/execute-phase.md',
+  '.claude/commands/mindforge/verify-phase.md',
+  '.claude/commands/mindforge/ship.md',
+  '.claude/commands/mindforge/audit.md',
+  '.claude/commands/mindforge/milestone.md',
+  '.claude/commands/mindforge/complete-milestone.md',
+  '.claude/commands/mindforge/approve.md',
+  '.claude/commands/mindforge/sync-jira.md',
+  '.claude/commands/mindforge/sync-confluence.md',
+  '.mindforge/personas/analyst.md',
+  '.mindforge/personas/architect.md',
+  '.mindforge/personas/developer.md',
+  '.mindforge/personas/qa-engineer.md',
+  '.mindforge/personas/security-reviewer.md',
+  '.mindforge/personas/tech-writer.md',
+  '.mindforge/personas/debug-specialist.md',
+  '.mindforge/personas/release-manager.md',
+  '.mindforge/skills/security-review/SKILL.md',
+  '.mindforge/skills/code-quality/SKILL.md',
+  '.mindforge/skills/api-design/SKILL.md',
+  '.mindforge/skills/testing-standards/SKILL.md',
+  '.mindforge/skills/documentation/SKILL.md',
+  '.mindforge/org/ORG.md',
+  '.mindforge/org/CONVENTIONS.md',
+  '.mindforge/org/SECURITY.md',
+  '.mindforge/org/TOOLS.md',
+  '.mindforge/integrations/connection-manager.md',
+  '.mindforge/integrations/jira.md',
+  '.mindforge/integrations/confluence.md',
+  '.mindforge/integrations/slack.md',
+  '.mindforge/integrations/github.md',
+  '.mindforge/integrations/gitlab.md',
+  '.mindforge/governance/change-classifier.md',
+  '.mindforge/governance/approval-workflow.md',
+  '.mindforge/governance/compliance-gates.md',
+  '.mindforge/governance/GOVERNANCE-CONFIG.md',
+  '.mindforge/team/multi-handoff.md',
+  '.mindforge/team/session-merger.md',
+  '.mindforge/org/integrations/INTEGRATIONS-CONFIG.md',
+  '.planning/STATE.md',
+  '.planning/HANDOFF.json',
+  '.planning/jira-sync.json',
+  '.planning/slack-threads.json',
+  'bin/install.js',
+  'package.json',
+  'README.md',
+  'docs/enterprise-setup.md',
+  'docs/governance-guide.md',
+];
+files.forEach(f => test(f, () => assert.ok(fs.existsSync(f), `Missing: ${f}`)));
+
+// ── Content tests ─────────────────────────────────────────────────────────────
+console.log('\nContent validation:');
+
+test('CLAUDE.md has session start protocol', () => {
+  const content = fs.readFileSync('.claude/CLAUDE.md', 'utf8');
+  assert.ok(content.includes('SESSION START PROTOCOL'), 'Missing session start protocol');
+  assert.ok(content.includes('PLAN-FIRST RULE'), 'Missing plan-first rule');
+  assert.ok(content.includes('Quality gates'), 'Missing quality gates');
+  assert.ok(content.includes('SECURITY AUTO-TRIGGER'), 'Missing security auto-trigger');
+  assert.ok(content.includes('/mindforge:audit'), 'Missing Day 4 command awareness');
+  assert.ok(content.includes('Tier 3'), 'Missing governance tier awareness');
+});
+
+test('CLAUDE.md and .agent/CLAUDE.md are identical', () => {
+  const claude = fs.readFileSync('.claude/CLAUDE.md', 'utf8');
+  const agent = fs.readFileSync('.agent/CLAUDE.md', 'utf8');
+  assert.strictEqual(claude, agent, '.claude/CLAUDE.md and .agent/CLAUDE.md differ');
+});
+
+test('All 6 commands mirrored to .agent/mindforge/', () => {
+  const claudeCommands = fs.readdirSync('.claude/commands/mindforge/').sort();
+  const agentCommands = fs.readdirSync('.agent/mindforge/').sort();
+  assert.deepStrictEqual(claudeCommands, agentCommands, 'Command files differ between runtimes');
+});
+
+test('HANDOFF.json is valid JSON', () => {
+  const content = fs.readFileSync('.planning/HANDOFF.json', 'utf8');
+  const parsed = JSON.parse(content);
+  assert.ok(parsed.schema_version, 'Missing schema_version field');
+  assert.ok(parsed._warning, 'Missing _warning anti-secret field');
+});
+
+test('package.json has bin field', () => {
+  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  assert.ok(pkg.bin, 'Missing bin field');
+  assert.ok(pkg.bin.mindforge, 'Missing bin.mindforge');
+  assert.ok(pkg.engines, 'Missing engines field');
+  assert.ok(pkg.engines.node, 'Missing engines.node');
+});
+
+test('All skill packs have frontmatter triggers', () => {
+  const skillDirs = fs.readdirSync('.mindforge/skills/');
+  skillDirs.forEach(dir => {
+    const skillPath = `.mindforge/skills/${dir}/SKILL.md`;
+    if (fs.existsSync(skillPath)) {
+      const content = fs.readFileSync(skillPath, 'utf8');
+      assert.ok(content.includes('triggers:'), `${skillPath} missing triggers frontmatter`);
+      assert.ok(content.includes('name:'), `${skillPath} missing name frontmatter`);
+    }
+  });
+});
+
+test('bin/install.js is executable and has no obvious syntax errors', () => {
+  const stat = fs.statSync('bin/install.js');
+  assert.ok(stat.size > 1000, 'bin/install.js is suspiciously small');
+  const content = fs.readFileSync('bin/install.js', 'utf8');
+  assert.ok(content.includes('#!/usr/bin/env node'), 'Missing shebang line');
+  assert.ok(content.includes('verifyInstall'), 'Missing install verification function');
+});
+
+test('No secrets in any committed file', () => {
+  const secretPatterns = [
+    /password\s*=\s*['"][^'"]{6,}/i,
+    /api[_-]?key\s*=\s*['"][^'"]{10,}/i,
+    /secret\s*=\s*['"][^'"]{8,}/i,
+    /-----BEGIN (RSA |EC |PRIVATE )?KEY-----/,
+    /sk-[a-zA-Z0-9]{20,}/,
+  ];
+
+  function scanDir(dir) {
+    if (dir.includes('node_modules') || dir.includes('.git')) return;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    entries.forEach(entry => {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scanDir(full);
+      } else if (entry.name.endsWith('.md') || entry.name.endsWith('.js') || entry.name.endsWith('.json')) {
+        const content = fs.readFileSync(full, 'utf8');
+        secretPatterns.forEach(pattern => {
+          assert.ok(!pattern.test(content), `Potential secret in ${full}`);
+        });
+      }
+    });
+  }
+
+  scanDir('.');
+});
+
+// ── Results ───────────────────────────────────────────────────────────────────
+console.log(`\n${'─'.repeat(50)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+
+if (failed > 0) {
+  console.error(`\n❌ ${failed} test(s) failed. Fix before pushing.\n`);
+  process.exit(1);
+} else {
+  console.log(`\n✅ All tests passed. Day 1 foundation is solid.\n`);
+}

package/tests/integrations.test.js

@@ -0,0 +1,128 @@
+/**
+ * MindForge Day 4 — Enterprise Integration Tests
+ * Run: node tests/integrations.test.js
+ */
+
+const fs = require('fs');
+const assert = require('assert');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ✅ ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  ❌ ${name}`);
+    console.error(`     ${err.message}`);
+    failed++;
+  }
+}
+
+function read(file) {
+  return fs.readFileSync(file, 'utf8');
+}
+
+console.log('\nMindForge Day 4 — Integration Tests\n');
+
+console.log('Scaffold and config:');
+
+[
+  '.mindforge/integrations/connection-manager.md',
+  '.mindforge/integrations/jira.md',
+  '.mindforge/integrations/confluence.md',
+  '.mindforge/integrations/slack.md',
+  '.mindforge/integrations/github.md',
+  '.mindforge/integrations/gitlab.md',
+  '.mindforge/org/integrations/INTEGRATIONS-CONFIG.md',
+  '.planning/jira-sync.json',
+  '.planning/slack-threads.json',
+].forEach(file => {
+  test(`${file} exists`, () => assert.ok(fs.existsSync(file), `Missing ${file}`));
+});
+
+console.log('\nSecurity hardening:');
+
+test('integration config contains no token values', () => {
+  const content = read('.mindforge/org/integrations/INTEGRATIONS-CONFIG.md');
+  const forbidden = [/ghp_[a-zA-Z0-9]+/, /xoxb-[a-zA-Z0-9-]+/, /sk-[a-zA-Z0-9]+/, /API_TOKEN=\S+/];
+  forbidden.forEach(pattern => {
+    assert.ok(!pattern.test(content), `Potential token leaked in config: ${pattern}`);
+  });
+});
+
+test('connection manager documents shell debug prohibition and curl verbose prohibition', () => {
+  const content = read('.mindforge/integrations/connection-manager.md');
+  assert.ok(content.includes('Debug mode prohibition'), 'Missing debug mode guidance');
+  assert.ok(content.includes('curl verbose mode prohibition'), 'Missing curl verbose guidance');
+  assert.ok(content.includes('set +x'), 'Missing explicit set +x guidance');
+});
+
+test('audit schema and audit command document archive rotation after 10000 lines', () => {
+  const schema = read('.mindforge/audit/AUDIT-SCHEMA.md');
+  const command = read('.claude/commands/mindforge/audit.md');
+  assert.ok(schema.includes('10,000 lines'), 'Missing audit rotation threshold in schema');
+  assert.ok(command.includes('10,000 lines'), 'Missing audit rotation threshold in command');
+});
+
+console.log('\nJira behaviour:');
+
+test('jira integration uses dynamic transition lookup instead of hardcoded IDs', () => {
+  const content = read('.mindforge/integrations/jira.md');
+  assert.ok(content.includes('Never hardcode transition IDs'), 'Missing dynamic lookup guidance');
+  assert.ok(content.includes('GET /rest/api/3/issue/{issueKey}/transitions'), 'Missing transitions lookup endpoint');
+  assert.ok(content.includes('transition_cache'), 'Missing transition cache guidance');
+});
+
+test('jira-sync.json includes anti-secret warning', () => {
+  const parsed = JSON.parse(read('.planning/jira-sync.json'));
+  assert.ok(parsed._warning, 'Missing _warning');
+  assert.ok(parsed._warning.toLowerCase().includes('credentials'), 'Warning should mention credentials');
+});
+
+test('jira integration documents backoff and second-429 stop behaviour', () => {
+  const content = read('.mindforge/integrations/jira.md');
+  assert.ok(content.includes('429'), 'Missing rate limit handling');
+  assert.ok(content.includes('retry once'), 'Missing retry-once guidance');
+});
+
+console.log('\nConfluence and Slack resilience:');
+
+test('confluence integration requires idempotent updates', () => {
+  const content = read('.mindforge/integrations/confluence.md');
+  assert.ok(content.includes('idempotent'), 'Missing idempotency guidance');
+  assert.ok(content.includes('Do not create duplicate pages'), 'Missing duplicate-page guidance');
+});
+
+test('slack thread schema is valid and guarded against token storage', () => {
+  const parsed = JSON.parse(read('.planning/slack-threads.json'));
+  assert.strictEqual(parsed.schema_version, '1.0.0');
+  assert.ok(parsed.threads && typeof parsed.threads === 'object', 'Missing threads object');
+  assert.ok(parsed._warning.toLowerCase().includes('tokens'), 'Warning should mention tokens');
+});
+
+test('slack integration handles invalid thread timestamps and undelivered critical alerts', () => {
+  const content = read('.mindforge/integrations/slack.md');
+  assert.ok(content.includes('clear that entry'), 'Missing invalid thread handling');
+  assert.ok(content.includes('Undelivered alerts'), 'Missing undelivered critical alert handling');
+});
+
+console.log('\nGitHub correctness:');
+
+test('github integration treats branch-protection 404 as non-fatal and checks branch diff before PR', () => {
+  const content = read('.mindforge/integrations/github.md');
+  assert.ok(content.includes('404'), 'Missing branch protection 404 handling');
+  assert.ok(content.includes('git log origin/${GITHUB_DEFAULT_BRANCH}..HEAD --oneline | wc -l'), 'Missing ahead-of-base check');
+});
+
+console.log(`\n${'─'.repeat(50)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+
+if (failed > 0) {
+  console.error(`\n❌ ${failed} test(s) failed.\n`);
+  process.exit(1);
+} else {
+  console.log('\n✅ All integration tests passed.\n');
+}

package/tests/intelligence.test.js

@@ -0,0 +1,117 @@
+'use strict';
+
+const fs = require('fs');
+const assert = require('assert');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ✅ ${name}`);
+    passed += 1;
+  } catch (err) {
+    console.error(`  ❌ ${name}`);
+    console.error(`     ${err.message}`);
+    failed += 1;
+  }
+}
+
+function read(p) {
+  return fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : '';
+}
+
+console.log('\nMindForge Day 5 — Intelligence Tests\n');
+
+console.log('Files:');
+[
+  '.mindforge/intelligence/health-engine.md',
+  '.mindforge/intelligence/difficulty-scorer.md',
+  '.mindforge/intelligence/antipattern-detector.md',
+  '.mindforge/intelligence/skill-gap-analyser.md',
+  '.mindforge/intelligence/smart-compaction.md',
+  '.mindforge/team/TEAM-PROFILE.md',
+  '.mindforge/team/profiles/README.md',
+  'MINDFORGE.md',
+  'bin/wizard/setup-wizard.js',
+  'bin/wizard/environment-detector.js',
+  'bin/wizard/config-generator.js',
+  '.claude/commands/mindforge/health.md',
+  '.claude/commands/mindforge/retrospective.md',
+  '.claude/commands/mindforge/profile-team.md',
+  '.claude/commands/mindforge/metrics.md',
+].forEach((p) => test(`${p} exists`, () => assert.ok(fs.existsSync(p), `Missing: ${p}`)));
+
+console.log('\nReview/hardening checks:');
+
+test('health engine required list includes Day 5 command files', () => {
+  const c = read('.mindforge/intelligence/health-engine.md');
+  assert.ok(c.includes('health.md'));
+  assert.ok(c.includes('retrospective.md'));
+  assert.ok(c.includes('profile-team.md'));
+  assert.ok(c.includes('metrics.md'));
+});
+
+test('health engine includes audit quarantine approach', () => {
+  const c = read('.mindforge/intelligence/health-engine.md');
+  assert.ok(c.includes('AUDIT.jsonl.quarantine'));
+  assert.ok(c.toLowerCase().includes('never delete lines'));
+});
+
+test('antipattern detector excludes test files for C01', () => {
+  const c = read('.mindforge/intelligence/antipattern-detector.md');
+  assert.ok(c.includes('*.test.ts'));
+  assert.ok(c.includes('*.spec.ts'));
+  assert.ok(c.includes('type-guard'));
+});
+
+test('antipattern detector includes cursor pagination exception', () => {
+  const c = read('.mindforge/intelligence/antipattern-detector.md');
+  assert.ok(c.includes('cursor:'));
+  assert.ok(c.includes('B03'));
+});
+
+test('smart compaction includes Level 1/2/3 and inconsistency file display', () => {
+  const c = read('.mindforge/intelligence/smart-compaction.md');
+  assert.ok(c.includes('Level 1'));
+  assert.ok(c.includes('Level 2'));
+  assert.ok(c.includes('Level 3'));
+  assert.ok(c.includes('first 50 lines'));
+});
+
+test('difficulty scorer includes migration context handling and split recommendation', () => {
+  const c = read('.mindforge/intelligence/difficulty-scorer.md');
+  assert.ok(c.includes('migration'));
+  assert.ok(c.includes('/mindforge:discuss-phase [N] --split'));
+});
+
+test('MINDFORGE has non-overridable section', () => {
+  const c = read('MINDFORGE.md');
+  assert.ok(c.includes('NON-OVERRIDABLE'));
+});
+
+test('retrospective command includes MINDFORGE feedback step', () => {
+  const c = read('.claude/commands/mindforge/retrospective.md');
+  assert.ok(c.includes('MINDFORGE.md'));
+  assert.ok(c.toLowerCase().includes('apply learnings'));
+});
+
+test('wizard checks stdin tty for interactivity', () => {
+  const c = read('bin/wizard/setup-wizard.js');
+  assert.ok(c.includes('process.stdin.isTTY'));
+});
+
+test('environment detector checks devDependencies', () => {
+  const c = read('bin/wizard/environment-detector.js');
+  assert.ok(c.includes('devDependencies'));
+});
+
+test('config generator uses idempotent already configured behavior', () => {
+  const c = read('bin/wizard/config-generator.js');
+  assert.ok(c.includes('already configured'));
+});
+
+console.log(`\n${'─'.repeat(50)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/metrics.test.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const fs = require('fs');
+const assert = require('assert');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ✅ ${name}`);
+    passed += 1;
+  } catch (err) {
+    console.error(`  ❌ ${name}`);
+    console.error(`     ${err.message}`);
+    failed += 1;
+  }
+}
+
+function read(p) {
+  return fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : '';
+}
+
+function calcScore(opts = {}) {
+  const {
+    tasksFailed = 0,
+    qualityGatesFailed = 0,
+    critical = 0,
+    high = 0,
+    medium = 0,
+  } = opts;
+  let s = 100;
+  s -= tasksFailed * 15;
+  s -= qualityGatesFailed * 10;
+  s -= critical * 30;
+  s -= high * 15;
+  s -= medium * 5;
+  if (!qualityGatesFailed) s += 5;
+  if (!critical && !high) s += 5;
+  return Math.max(0, Math.min(100, s));
+}
+
+console.log('\nMindForge Day 5 — Metrics Tests\n');
+
+console.log('Files:');
+[
+  '.mindforge/metrics/METRICS-SCHEMA.md',
+  '.mindforge/metrics/quality-tracker.md',
+  '.mindforge/team/TEAM-PROFILE.md',
+].forEach((p) => test(`${p} exists`, () => assert.ok(fs.existsSync(p), `Missing: ${p}`)));
+
+console.log('\nSchema checks:');
+
+test('metrics schema defines compaction-quality.jsonl', () => {
+  const c = read('.mindforge/metrics/METRICS-SCHEMA.md');
+  assert.ok(c.includes('compaction-quality.jsonl'));
+});
+
+test('metrics schema defines trigger_type in skill usage', () => {
+  const c = read('.mindforge/metrics/METRICS-SCHEMA.md');
+  assert.ok(c.includes('trigger_type'));
+});
+
+test('metrics schema defines session_quality_score', () => {
+  const c = read('.mindforge/metrics/METRICS-SCHEMA.md');
+  assert.ok(c.includes('session_quality_score'));
+});
+
+test('quality tracker includes automatic adjustments', () => {
+  const c = read('.mindforge/metrics/quality-tracker.md').toLowerCase();
+  assert.ok(c.includes('automatic adjustments'));
+});
+
+test('team profile includes non-evaluative metrics policy', () => {
+  const c = read('.mindforge/team/TEAM-PROFILE.md').toLowerCase();
+  assert.ok(c.includes('not developer performance'));
+});
+
+console.log('\nScore behavior:');
+
+test('perfect score clamps to 100', () => {
+  assert.strictEqual(calcScore({}), 100);
+});
+
+test('heavy failure scenario clamps to 0', () => {
+  assert.strictEqual(calcScore({ tasksFailed: 10, qualityGatesFailed: 5, critical: 3 }), 0);
+});
+
+test('one task failure lowers score below 100', () => {
+  assert.ok(calcScore({ tasksFailed: 1 }) < 100);
+});
+
+console.log(`\n${'─'.repeat(50)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);