aios-core 4.0.2 → 4.1.0

package/.aios-core/core/synapse/diagnostics/collectors/hook-collector.js

@@ -0,0 +1,129 @@
+/**
+ * Hook Collector — Verifies SYNAPSE hook registration and file integrity.
+ *
+ * Checks:
+ * - settings.local.json has UserPromptSubmit hook entry
+ * - Hook file exists at expected path
+ * - Hook file is valid Node.js (can be required)
+ *
+ * @module core/synapse/diagnostics/collectors/hook-collector
+ * @version 1.0.0
+ * @created Story SYN-13
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Collect hook registration and integrity data.
+ *
+ * @param {string} projectRoot - Absolute path to project root
+ * @returns {{ checks: Array<{ name: string, status: string, detail: string }> }}
+ */
+function collectHookStatus(projectRoot) {
+  const checks = [];
+
+  // Check 1: settings.local.json has hook entry
+  const settingsPath = path.join(projectRoot, '.claude', 'settings.local.json');
+  let hasHookRegistered = false;
+
+  try {
+    if (fs.existsSync(settingsPath)) {
+      const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+      const hooks = settings.hooks || {};
+      const promptHooks = hooks.UserPromptSubmit || hooks.userPromptSubmit || [];
+
+      hasHookRegistered = promptHooks.some((entry) => {
+        // Flat format: { command: "node ..." } or string
+        const flatCmd = typeof entry === 'string' ? entry : (entry.command || '');
+        if (flatCmd.includes('synapse-engine')) return true;
+        // Nested format (Claude Code actual): { hooks: [{ type, command }] }
+        if (Array.isArray(entry.hooks)) {
+          return entry.hooks.some((h) => {
+            const cmd = typeof h === 'string' ? h : (h.command || '');
+            return cmd.includes('synapse-engine');
+          });
+        }
+        return false;
+      });
+
+      checks.push({
+        name: 'Hook registered',
+        status: hasHookRegistered ? 'PASS' : 'FAIL',
+        detail: hasHookRegistered
+          ? 'settings.local.json has UserPromptSubmit entry for synapse-engine'
+          : 'No synapse-engine hook found in settings.local.json',
+      });
+    } else {
+      checks.push({
+        name: 'Hook registered',
+        status: 'FAIL',
+        detail: 'settings.local.json not found',
+      });
+    }
+  } catch (error) {
+    checks.push({
+      name: 'Hook registered',
+      status: 'ERROR',
+      detail: `Failed to read settings: ${error.message}`,
+    });
+  }
+
+  // Check 2: Hook file exists
+  const hookPath = path.join(projectRoot, '.claude', 'hooks', 'synapse-engine.js');
+  const hookExists = fs.existsSync(hookPath);
+
+  if (hookExists) {
+    try {
+      const stat = fs.statSync(hookPath);
+      const lineCount = fs.readFileSync(hookPath, 'utf8').split('\n').length;
+      checks.push({
+        name: 'Hook file exists',
+        status: 'PASS',
+        detail: `.claude/hooks/synapse-engine.js (${lineCount} lines, ${stat.size} bytes)`,
+      });
+    } catch (error) {
+      checks.push({
+        name: 'Hook file exists',
+        status: 'ERROR',
+        detail: `File exists but cannot be read: ${error.message}`,
+      });
+    }
+  } else {
+    checks.push({
+      name: 'Hook file exists',
+      status: 'FAIL',
+      detail: '.claude/hooks/synapse-engine.js not found',
+    });
+  }
+
+  // Check 3: Hook file is valid Node.js
+  if (hookExists) {
+    try {
+      require.resolve(hookPath);
+      checks.push({
+        name: 'Hook executable',
+        status: 'PASS',
+        detail: 'node can resolve the hook file',
+      });
+    } catch (error) {
+      checks.push({
+        name: 'Hook executable',
+        status: 'FAIL',
+        detail: `Cannot resolve: ${error.message}`,
+      });
+    }
+  } else {
+    checks.push({
+      name: 'Hook executable',
+      status: 'SKIP',
+      detail: 'Hook file does not exist',
+    });
+  }
+
+  return { checks };
+}
+
+module.exports = { collectHookStatus };

package/.aios-core/core/synapse/diagnostics/collectors/manifest-collector.js

@@ -0,0 +1,82 @@
+/**
+ * Manifest Collector — Validates manifest integrity vs. domain files.
+ *
+ * Checks:
+ * - Every domain in manifest has a corresponding file
+ * - Every domain file in .synapse/ has a manifest entry
+ *
+ * @module core/synapse/diagnostics/collectors/manifest-collector
+ * @version 1.0.0
+ * @created Story SYN-13
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { parseManifest } = require('../../domain/domain-loader');
+
+/**
+ * Collect manifest integrity data.
+ *
+ * @param {string} projectRoot - Absolute path to project root
+ * @returns {{ entries: Array<{ domain: string, inManifest: string, fileExists: boolean, status: string }>, orphanedFiles: string[] }}
+ */
+function collectManifestIntegrity(projectRoot) {
+  const synapsePath = path.join(projectRoot, '.synapse');
+  const manifestPath = path.join(synapsePath, 'manifest');
+  const entries = [];
+  const orphanedFiles = [];
+
+  // Parse manifest
+  const manifest = parseManifest(manifestPath);
+
+  // Check each domain in manifest has a file
+  for (const [_domainName, domainConfig] of Object.entries(manifest.domains)) {
+    const fileName = domainConfig.file;
+    const domainFilePath = path.join(synapsePath, fileName);
+    const fileExists = fs.existsSync(domainFilePath);
+
+    const stateInfo = domainConfig.state || 'unknown';
+    const triggers = [];
+    if (domainConfig.agentTrigger) triggers.push(`trigger=${domainConfig.agentTrigger}`);
+    if (domainConfig.workflowTrigger) triggers.push(`trigger=${domainConfig.workflowTrigger}`);
+    if (domainConfig.alwaysOn) triggers.push('ALWAYS_ON');
+
+    entries.push({
+      domain: fileName,
+      inManifest: `${stateInfo}${triggers.length ? ', ' + triggers.join(', ') : ''}`,
+      fileExists,
+      status: fileExists ? 'PASS' : 'FAIL',
+    });
+  }
+
+  // Check for orphaned domain files (files not in manifest)
+  const manifestFileNames = new Set(
+    Object.values(manifest.domains).map((d) => d.file),
+  );
+
+  try {
+    const allFiles = fs.readdirSync(synapsePath);
+    const domainFiles = allFiles.filter((f) => {
+      // Skip known non-domain files
+      if (f === 'manifest' || f === '.gitignore' || f.startsWith('.')) return false;
+      // Skip directories
+      const stat = fs.statSync(path.join(synapsePath, f));
+      if (stat.isDirectory()) return false;
+      return true;
+    });
+
+    for (const file of domainFiles) {
+      if (!manifestFileNames.has(file)) {
+        orphanedFiles.push(file);
+      }
+    }
+  } catch (_) {
+    // .synapse/ not readable
+  }
+
+  return { entries, orphanedFiles };
+}
+
+module.exports = { collectManifestIntegrity };

package/.aios-core/core/synapse/diagnostics/collectors/output-analyzer.js

@@ -0,0 +1,134 @@
+/**
+ * Output Analyzer — Per-component quality checks for UAP loaders and Hook layers.
+ *
+ * Examines the actual output quality beyond binary pass/fail by checking:
+ * - UAP loaders: Did the loader produce meaningful data?
+ * - Hook layers: Did the layer produce rules? How many?
+ *
+ * @module core/synapse/diagnostics/collectors/output-analyzer
+ * @version 1.0.0
+ * @created Story SYN-14
+ */
+
+'use strict';
+
+const path = require('path');
+const { safeReadJson } = require('./safe-read-json');
+
+/**
+ * Expected UAP loader output characteristics.
+ * @type {Object.<string, { minFields: number, description: string }>}
+ */
+const UAP_OUTPUT_EXPECTATIONS = {
+  agentConfig: { minFields: 3, description: 'Should have name, id, title at minimum' },
+  permissionMode: { minFields: 1, description: 'Should have mode value' },
+  gitConfig: { minFields: 1, description: 'Should have branch name' },
+  sessionContext: { minFields: 1, description: 'Should have session type' },
+  projectStatus: { minFields: 1, description: 'Should have status data' },
+  memories: { minFields: 0, description: 'Optional — Pro feature' },
+  synapseSession: { minFields: 1, description: 'Should have bridge write confirmation' },
+};
+
+/**
+ * Analyze output quality from persisted metrics.
+ *
+ * @param {string} projectRoot - Absolute path to project root
+ * @returns {{
+ *   available: boolean,
+ *   uapAnalysis: Array<{ name: string, status: string, quality: string, detail: string }>,
+ *   hookAnalysis: Array<{ name: string, status: string, rules: number, quality: string, detail: string }>,
+ *   summary: { uapHealthy: number, uapTotal: number, hookHealthy: number, hookTotal: number }
+ * }}
+ */
+function collectOutputAnalysis(projectRoot) {
+  const metricsDir = path.join(projectRoot, '.synapse', 'metrics');
+
+  const uapData = safeReadJson(path.join(metricsDir, 'uap-metrics.json'));
+  const hookData = safeReadJson(path.join(metricsDir, 'hook-metrics.json'));
+
+  if (!uapData && !hookData) {
+    return {
+      available: false,
+      uapAnalysis: [],
+      hookAnalysis: [],
+      summary: { uapHealthy: 0, uapTotal: 0, hookHealthy: 0, hookTotal: 0 },
+    };
+  }
+
+  const uapAnalysis = _analyzeUapOutput(uapData);
+  const hookAnalysis = _analyzeHookOutput(hookData);
+
+  return {
+    available: true,
+    uapAnalysis,
+    hookAnalysis,
+    summary: {
+      uapHealthy: uapAnalysis.filter(a => a.quality === 'good').length,
+      uapTotal: uapAnalysis.length,
+      hookHealthy: hookAnalysis.filter(a => a.quality === 'good').length,
+      hookTotal: hookAnalysis.length,
+    },
+  };
+}
+
+/**
+ * Analyze UAP loader outputs.
+ * @param {Object|null} data
+ * @returns {Array<{ name: string, status: string, quality: string, detail: string }>}
+ */
+function _analyzeUapOutput(data) {
+  if (!data || !data.loaders) return [];
+
+  return Object.entries(UAP_OUTPUT_EXPECTATIONS).map(([name, _expectation]) => {
+    const loader = data.loaders[name];
+    if (!loader) {
+      const desc = _expectation.description || '';
+      const detail = desc.includes('Optional') ? desc : 'Loader not present in metrics';
+      return { name, status: 'missing', quality: 'none', detail };
+    }
+    if (loader.status === 'error') {
+      return { name, status: 'error', quality: 'bad', detail: `Error: ${loader.error || 'unknown'}` };
+    }
+    if (loader.status === 'timeout') {
+      return { name, status: 'timeout', quality: 'bad', detail: `Timeout after ${loader.duration || 0}ms` };
+    }
+    if (loader.status === 'skipped') {
+      return { name, status: 'skipped', quality: 'none', detail: 'Loader was skipped' };
+    }
+    // Status 'ok' — check duration for anomalies
+    if (loader.duration > 200) {
+      return { name, status: 'ok', quality: 'degraded', detail: `Slow: ${loader.duration}ms (>200ms)` };
+    }
+    return { name, status: 'ok', quality: 'good', detail: `${loader.duration}ms` };
+  });
+}
+
+/**
+ * Analyze Hook layer outputs.
+ * @param {Object|null} data
+ * @returns {Array<{ name: string, status: string, rules: number, quality: string, detail: string }>}
+ */
+function _analyzeHookOutput(data) {
+  if (!data || !data.perLayer) return [];
+
+  return Object.entries(data.perLayer).map(([name, info]) => {
+    const rules = info.rules || 0;
+    const status = info.status || 'unknown';
+
+    if (status === 'error') {
+      return { name, status, rules, quality: 'bad', detail: 'Error in layer' };
+    }
+    if (status === 'skipped') {
+      return { name, status, rules, quality: 'none', detail: info.reason || 'Skipped' };
+    }
+    if (status === 'ok' && rules === 0) {
+      return { name, status, rules, quality: 'empty', detail: 'Loaded but produced 0 rules' };
+    }
+    if (status === 'ok' && rules > 0) {
+      return { name, status, rules, quality: 'good', detail: `${rules} rules in ${info.duration || 0}ms` };
+    }
+    return { name, status, rules, quality: 'unknown', detail: `Status: ${status}` };
+  });
+}
+
+module.exports = { collectOutputAnalysis, UAP_OUTPUT_EXPECTATIONS };

package/.aios-core/core/synapse/diagnostics/collectors/pipeline-collector.js

@@ -0,0 +1,75 @@
+/**
+ * Pipeline Collector — Simulates engine pipeline for expected vs. actual comparison.
+ *
+ * Calculates which layers should be active for the current bracket
+ * and compares against what was actually loaded.
+ *
+ * @module core/synapse/diagnostics/collectors/pipeline-collector
+ * @version 1.0.0
+ * @created Story SYN-13
+ */
+
+'use strict';
+
+const {
+  estimateContextPercent,
+  calculateBracket,
+  getActiveLayers,
+} = require('../../context/context-tracker');
+
+const LAYER_NAMES = {
+  0: 'L0 Constitution',
+  1: 'L1 Global',
+  2: 'L2 Agent',
+  3: 'L3 Workflow',
+  4: 'L4 Task',
+  5: 'L5 Squad',
+  6: 'L6 Keyword',
+  7: 'L7 Star-Command',
+};
+
+/**
+ * Collect pipeline simulation data.
+ *
+ * @param {number} promptCount - Current prompt count from session
+ * @param {string|null} activeAgentId - Active agent ID (for L2 match check)
+ * @param {object} manifest - Parsed manifest object
+ * @returns {{ bracket: string, contextPercent: number, layers: Array<{ layer: string, expected: string, status: string }> }}
+ */
+function collectPipelineSimulation(promptCount, activeAgentId, manifest) {
+  const contextPercent = estimateContextPercent(promptCount || 0);
+  const bracket = calculateBracket(contextPercent);
+  const layerConfig = getActiveLayers(bracket);
+
+  const activeLayers = layerConfig ? layerConfig.layers : [];
+  const layers = [];
+
+  for (let i = 0; i <= 7; i++) {
+    const layerName = LAYER_NAMES[i] || `L${i}`;
+    const isActive = activeLayers.includes(i);
+
+    let expected = isActive ? 'ACTIVE' : `SKIP (${bracket})`;
+    let status = 'PASS';
+
+    // For L2, check if active agent has a matching domain
+    if (i === 2 && isActive && activeAgentId) {
+      const domains = manifest?.domains || {};
+      const hasMatchingDomain = Object.values(domains).some(
+        (d) => d.agentTrigger === activeAgentId,
+      );
+
+      if (hasMatchingDomain) {
+        expected = `ACTIVE (agent: ${activeAgentId})`;
+      } else {
+        expected = `ACTIVE (no domain for ${activeAgentId})`;
+        status = 'WARN';
+      }
+    }
+
+    layers.push({ layer: layerName, expected, status });
+  }
+
+  return { bracket, contextPercent, layers };
+}
+
+module.exports = { collectPipelineSimulation };

package/.aios-core/core/synapse/diagnostics/collectors/quality-collector.js

@@ -0,0 +1,252 @@
+/**
+ * Quality Collector — Scores context relevance for UAP loaders and SYNAPSE layers.
+ *
+ * Uses weighted rubrics to produce a 0-100 score for each pipeline,
+ * then combines them into an overall grade.
+ *
+ * @module core/synapse/diagnostics/collectors/quality-collector
+ * @version 1.0.0
+ * @created Story SYN-12
+ */
+
+'use strict';
+
+const path = require('path');
+const { safeReadJson } = require('./safe-read-json');
+
+/**
+ * UAP loader scoring rubric.
+ * Weight = max points for this loader. Criticality = human label.
+ * @type {Array<{ name: string, weight: number, criticality: string, impact: string }>}
+ */
+const UAP_RUBRIC = [
+  { name: 'agentConfig', weight: 25, criticality: 'CRITICAL', impact: 'Agent identity and commands' },
+  { name: 'memories', weight: 20, criticality: 'HIGH', impact: 'Context from progressive retrieval' },
+  { name: 'sessionContext', weight: 15, criticality: 'MEDIUM', impact: 'Session continuity' },
+  { name: 'projectStatus', weight: 12, criticality: 'MEDIUM', impact: 'Project status context' },
+  { name: 'gitConfig', weight: 8, criticality: 'LOW', impact: 'Branch name context' },
+  { name: 'permissionMode', weight: 5, criticality: 'LOW', impact: 'Permission badge visual' },
+  { name: 'synapseSession', weight: 5, criticality: 'LOW', impact: 'Bridge write for SYNAPSE' },
+];
+
+/**
+ * Hook layer scoring rubric.
+ * @type {Array<{ name: string, weight: number, criticality: string, impact: string }>}
+ */
+const HOOK_RUBRIC = [
+  { name: 'constitution', weight: 25, criticality: 'CRITICAL', impact: 'Framework principles' },
+  { name: 'agent', weight: 25, criticality: 'CRITICAL', impact: 'Agent-specific instructions' },
+  { name: 'global', weight: 20, criticality: 'CRITICAL', impact: 'Project-wide rules' },
+  { name: 'workflow', weight: 10, criticality: 'MEDIUM', impact: 'Workflow context' },
+  { name: 'task', weight: 10, criticality: 'MEDIUM', impact: 'Task instructions' },
+  { name: 'squad', weight: 5, criticality: 'LOW', impact: 'Squad rules' },
+  { name: 'keyword', weight: 3, criticality: 'LOW', impact: 'Keyword triggers' },
+  { name: 'star-command', weight: 2, criticality: 'LOW', impact: 'Command-specific rules' },
+];
+
+/**
+ * Layers expected to be active per bracket.
+ * Used to adjust max possible score for hook layers.
+ * @type {Object.<string, string[]>}
+ */
+/** Maximum staleness threshold in ms (30 minutes).
+ * UAP metrics are written once at agent activation, so staleness > 5 min is normal.
+ * After this threshold, scores are degraded (50% penalty) rather than zeroed.
+ */
+const MAX_STALENESS_MS = 30 * 60 * 1000;
+
+/** Degradation factor applied to stale metrics (50% penalty). */
+const STALE_DEGRADATION_FACTOR = 0.5;
+
+const BRACKET_ACTIVE_LAYERS = {
+  FRESH: ['constitution', 'global', 'agent', 'star-command'],
+  MODERATE: ['constitution', 'global', 'agent', 'workflow', 'task', 'squad', 'keyword', 'star-command'],
+  DEPLETED: ['constitution', 'global', 'agent', 'workflow', 'task', 'squad', 'keyword', 'star-command'],
+  CRITICAL: ['constitution', 'agent'],
+};
+
+/**
+ * Grade thresholds.
+ * @param {number} score - Score 0-100
+ * @returns {string} Grade letter
+ */
+function _getGrade(score) {
+  if (score >= 90) return 'A';
+  if (score >= 75) return 'B';
+  if (score >= 60) return 'C';
+  if (score >= 45) return 'D';
+  return 'F';
+}
+
+/**
+ * Grade label.
+ * @param {string} grade
+ * @returns {string}
+ */
+function _getGradeLabel(grade) {
+  const labels = { A: 'EXCELLENT', B: 'GOOD', C: 'ADEQUATE', D: 'POOR', F: 'FAILING' };
+  return labels[grade] || 'UNKNOWN';
+}
+
+/**
+ * Collect context quality analysis from persisted metrics files.
+ *
+ * @param {string} projectRoot - Absolute path to project root
+ * @returns {{
+ *   uap: { available: boolean, score: number, maxPossible: number, loaders: Array },
+ *   hook: { available: boolean, score: number, maxPossible: number, bracket: string, layers: Array },
+ *   overall: { score: number, grade: string, label: string }
+ * }}
+ */
+function collectQualityMetrics(projectRoot) {
+  const metricsDir = path.join(projectRoot, '.synapse', 'metrics');
+  const now = Date.now();
+
+  const uapData = safeReadJson(path.join(metricsDir, 'uap-metrics.json'));
+  const hookData = safeReadJson(path.join(metricsDir, 'hook-metrics.json'));
+
+  // SYN-14: Staleness detection — stale data scores 0
+  const uapAge = uapData && uapData.timestamp ? now - new Date(uapData.timestamp).getTime() : 0;
+  const hookAge = hookData && hookData.timestamp ? now - new Date(hookData.timestamp).getTime() : 0;
+  const uapStale = uapAge > MAX_STALENESS_MS;
+  const hookStale = hookAge > MAX_STALENESS_MS;
+
+  // SYN-14 fix: Stale data is degraded (50% penalty) instead of zeroed.
+  // UAP writes once at activation; being "stale" after 5 min is normal behavior.
+  const uap = _scoreUap(uapData);
+  if (uapStale) uap.stale = true;
+  const hook = _scoreHook(hookData);
+  if (hookStale) hook.stale = true;
+
+  let uapNormalized = uap.maxPossible > 0 ? (uap.score / uap.maxPossible) * 100 : 0;
+  let hookNormalized = hook.maxPossible > 0 ? (hook.score / hook.maxPossible) * 100 : 0;
+  if (uapStale) uapNormalized *= STALE_DEGRADATION_FACTOR;
+  if (hookStale) hookNormalized *= STALE_DEGRADATION_FACTOR;
+
+  let overallScore;
+  if (uap.available && hook.available) {
+    overallScore = Math.round(uapNormalized * 0.4 + hookNormalized * 0.6);
+  } else if (uap.available) {
+    overallScore = Math.round(uapNormalized);
+  } else if (hook.available) {
+    overallScore = Math.round(hookNormalized);
+  } else {
+    overallScore = 0;
+  }
+
+  const grade = _getGrade(overallScore);
+
+  return {
+    uap: {
+      available: uap.available,
+      score: Math.round(uapNormalized),
+      maxPossible: uap.maxPossible,
+      loaders: uap.loaders,
+      stale: uapStale,
+    },
+    hook: {
+      available: hook.available,
+      score: Math.round(hookNormalized),
+      maxPossible: hook.maxPossible,
+      bracket: hook.bracket,
+      layers: hook.layers,
+      stale: hookStale,
+    },
+    overall: {
+      score: overallScore,
+      grade,
+      label: _getGradeLabel(grade),
+    },
+  };
+}
+
+/**
+ * Score UAP loaders based on rubric.
+ * @param {Object|null} data - Parsed uap-metrics.json
+ * @returns {{ available: boolean, score: number, maxPossible: number, loaders: Array }}
+ */
+function _scoreUap(data) {
+  if (!data || !data.loaders) {
+    return { available: false, score: 0, maxPossible: 0, loaders: [] };
+  }
+
+  const maxPossible = UAP_RUBRIC.reduce((sum, r) => sum + r.weight, 0);
+  let totalScore = 0;
+
+  const loaders = UAP_RUBRIC.map((rubric) => {
+    const loader = data.loaders[rubric.name];
+    const isOk = loader && loader.status === 'ok';
+    const score = isOk ? rubric.weight : 0;
+    totalScore += score;
+
+    return {
+      name: rubric.name,
+      score,
+      maxScore: rubric.weight,
+      criticality: rubric.criticality,
+      impact: rubric.impact,
+      status: loader ? loader.status : 'missing',
+    };
+  });
+
+  return { available: true, score: totalScore, maxPossible, loaders };
+}
+
+/**
+ * Score Hook layers based on rubric, adjusted by bracket.
+ * @param {Object|null} data - Parsed hook-metrics.json
+ * @returns {{ available: boolean, score: number, maxPossible: number, bracket: string, layers: Array }}
+ */
+function _scoreHook(data) {
+  if (!data || !data.perLayer) {
+    return { available: false, score: 0, maxPossible: 0, bracket: 'unknown', layers: [] };
+  }
+
+  const bracket = data.bracket || 'MODERATE';
+  const activeLayers = BRACKET_ACTIVE_LAYERS[bracket] || BRACKET_ACTIVE_LAYERS.MODERATE;
+
+  let totalScore = 0;
+  let maxPossible = 0;
+
+  const layers = HOOK_RUBRIC.map((rubric) => {
+    const isExpected = activeLayers.includes(rubric.name);
+    if (!isExpected) {
+      return {
+        name: rubric.name,
+        score: 0,
+        maxScore: 0,
+        criticality: rubric.criticality,
+        impact: rubric.impact,
+        status: 'not-expected',
+        rules: 0,
+      };
+    }
+
+    maxPossible += rubric.weight;
+    const layer = data.perLayer[rubric.name];
+    const isOk = layer && layer.status === 'ok';
+    const score = isOk ? rubric.weight : 0;
+    totalScore += score;
+
+    return {
+      name: rubric.name,
+      score,
+      maxScore: rubric.weight,
+      criticality: rubric.criticality,
+      impact: rubric.impact,
+      status: layer ? layer.status : 'missing',
+      rules: layer ? (layer.rules || 0) : 0,
+    };
+  });
+
+  return { available: true, score: totalScore, maxPossible, bracket, layers };
+}
+
+module.exports = {
+  collectQualityMetrics,
+  UAP_RUBRIC,
+  HOOK_RUBRIC,
+  BRACKET_ACTIVE_LAYERS,
+  MAX_STALENESS_MS,
+  STALE_DEGRADATION_FACTOR,
+};