@ryuenn3123/agentic-senior-core 2.0.4 → 2.0.7

package/scripts/governance-weekly-report.mjs

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+
+/**
+ * governance-weekly-report.mjs
+ *
+ * Aggregates weekly governance readiness signals for maintainers.
+ * Produces a machine-readable report with trend, trust, and release posture.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { calculateTrustScore } from './trust-scorer.mjs';
+
+const SCRIPT_FILE_PATH = fileURLToPath(import.meta.url);
+const SCRIPT_DIR = dirname(SCRIPT_FILE_PATH);
+const REPOSITORY_ROOT = resolve(SCRIPT_DIR, '..');
+const QUALITY_TREND_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'quality-trend-report.json');
+const REPORT_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'weekly-governance-report.json');
+const ARGUMENT_FLAGS = new Set(process.argv.slice(2));
+const isStdoutOnlyMode = ARGUMENT_FLAGS.has('--stdout-only');
+const WEEKLY_WINDOW_DAYS = 7;
+const HISTORY_LIMIT = 26;
+const REQUIRED_VERIFIED_DOMAINS = new Set(['cli', 'frontend', 'fullstack', 'distribution', 'review-quality']);
+
+function readJsonOrNull(filePath) {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function runJsonScript(scriptRelativePath, scriptArguments = []) {
+  const absoluteScriptPath = join(REPOSITORY_ROOT, scriptRelativePath);
+  const commandResult = spawnSync('node', [absoluteScriptPath, ...scriptArguments], {
+    cwd: REPOSITORY_ROOT,
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024 * 10,
+  });
+
+  const standardOutput = (commandResult.stdout || '').trim();
+  const standardError = (commandResult.stderr || '').trim();
+  const exitCode = typeof commandResult.status === 'number' ? commandResult.status : 1;
+
+  if (!standardOutput) {
+    return {
+      scriptPath: scriptRelativePath,
+      exitCode,
+      parsedReport: null,
+      parseError: 'Script produced no stdout JSON payload',
+      stderr: standardError,
+    };
+  }
+
+  try {
+    return {
+      scriptPath: scriptRelativePath,
+      exitCode,
+      parsedReport: JSON.parse(standardOutput),
+      parseError: null,
+      stderr: standardError,
+    };
+  } catch (jsonParseError) {
+    const parseErrorMessage = jsonParseError instanceof Error ? jsonParseError.message : String(jsonParseError);
+    return {
+      scriptPath: scriptRelativePath,
+      exitCode,
+      parsedReport: null,
+      parseError: parseErrorMessage,
+      stderr: standardError,
+    };
+  }
+}
+
+function loadQualityTrendReport() {
+  const existingQualityTrend = readJsonOrNull(QUALITY_TREND_PATH);
+  if (existingQualityTrend) {
+    return {
+      source: 'state-file',
+      report: existingQualityTrend,
+      freshness: existingQualityTrend.generatedAt || null,
+    };
+  }
+
+  const generatedQualityTrend = runJsonScript('scripts/quality-trend-report.mjs', ['--stdout-only']);
+  return {
+    source: 'generated-stdout',
+    report: generatedQualityTrend.parsedReport,
+    freshness: generatedQualityTrend.parsedReport?.generatedAt || null,
+    parseError: generatedQualityTrend.parseError,
+    exitCode: generatedQualityTrend.exitCode,
+  };
+}
+
+function collectCommitSignals(windowDays) {
+  const commitLogResult = spawnSync('git', ['log', `--since=${windowDays}.days`, '--pretty=format:%s'], {
+    cwd: REPOSITORY_ROOT,
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024,
+  });
+
+  if (commitLogResult.status !== 0) {
+    return {
+      windowDays,
+      commitCount: 0,
+      releaseCommitCount: 0,
+      rollbackCommitCount: 0,
+      releaseFrequencyPercent: null,
+      rollbackFrequencyPercent: null,
+      error: (commitLogResult.stderr || 'Failed to read git log').trim(),
+    };
+  }
+
+  const commitSubjects = (commitLogResult.stdout || '')
+    .split(/\r?\n/u)
+    .map((subjectLine) => subjectLine.trim())
+    .filter((subjectLine) => subjectLine.length > 0);
+
+  const commitCount = commitSubjects.length;
+  const releaseCommitCount = commitSubjects.filter((subjectLine) => /release|publish|chore\(release\)/i.test(subjectLine)).length;
+  const rollbackCommitCount = commitSubjects.filter((subjectLine) => /rollback|revert/i.test(subjectLine)).length;
+
+  return {
+    windowDays,
+    commitCount,
+    releaseCommitCount,
+    rollbackCommitCount,
+    releaseFrequencyPercent: commitCount === 0 ? 0 : Number(((releaseCommitCount / commitCount) * 100).toFixed(2)),
+    rollbackFrequencyPercent: commitCount === 0 ? 0 : Number(((rollbackCommitCount / commitCount) * 100).toFixed(2)),
+    error: null,
+  };
+}
+
+async function collectSkillTrustSignals() {
+  const skillDirectoryPath = join(REPOSITORY_ROOT, '.agent-context', 'skills');
+  const skillDirectoryEntries = await fs.readdir(skillDirectoryPath, { withFileTypes: true });
+  const skillDomainNames = skillDirectoryEntries
+    .filter((directoryEntry) => directoryEntry.isDirectory())
+    .map((directoryEntry) => directoryEntry.name)
+    .sort((leftDomainName, rightDomainName) => leftDomainName.localeCompare(rightDomainName));
+
+  const trustRows = [];
+  const tierCounts = {
+    verified: 0,
+    community: 0,
+    experimental: 0,
+  };
+
+  for (const skillDomainName of skillDomainNames) {
+    const trustResult = await calculateTrustScore(join(skillDirectoryPath, skillDomainName));
+
+    if (typeof tierCounts[trustResult.tier] === 'number') {
+      tierCounts[trustResult.tier] += 1;
+    }
+
+    trustRows.push({
+      domain: skillDomainName,
+      tier: trustResult.tier,
+      score: trustResult.score,
+    });
+  }
+
+  const requiredVerifiedDomainFailures = trustRows
+    .filter((trustRow) => REQUIRED_VERIFIED_DOMAINS.has(trustRow.domain) && trustRow.tier !== 'verified')
+    .map((trustRow) => trustRow.domain);
+
+  return {
+    domains: trustRows,
+    tierCounts,
+    requiredVerifiedDomains: Array.from(REQUIRED_VERIFIED_DOMAINS),
+    requiredVerifiedDomainFailures,
+    allRequiredVerified: requiredVerifiedDomainFailures.length === 0,
+  };
+}
+
+function buildBlockers(qualityTrendReport, skillTrustSignals, commitSignals) {
+  const blockers = [];
+
+  const qualityGatePassRatePercent = qualityTrendReport?.governanceHealth?.gatePassRatePercent;
+  if (typeof qualityGatePassRatePercent !== 'number' || qualityGatePassRatePercent < 100) {
+    blockers.push('Governance gate pass rate is below 100%.');
+  }
+
+  if (!skillTrustSignals.allRequiredVerified) {
+    blockers.push(
+      `Required verified skill domains missing: ${skillTrustSignals.requiredVerifiedDomainFailures.join(', ')}`
+    );
+  }
+
+  if (commitSignals.error) {
+    blockers.push(`Commit signal extraction failed: ${commitSignals.error}`);
+  }
+
+  return blockers;
+}
+
+function buildHistoryEntry(weeklyReport) {
+  return {
+    generatedAt: weeklyReport.generatedAt,
+    readinessStatus: weeklyReport.releaseReadiness.isReady ? 'ready' : 'blocked',
+    blockerCount: weeklyReport.releaseReadiness.blockers.length,
+    gatePassRatePercent: weeklyReport.qualitySignals.governanceHealth.gatePassRatePercent,
+    verifiedSkillDomainCount: weeklyReport.skillTrust.tierCounts.verified,
+    releaseFrequencyPercent: weeklyReport.commitSignals.releaseFrequencyPercent,
+    rollbackFrequencyPercent: weeklyReport.commitSignals.rollbackFrequencyPercent,
+  };
+}
+
+function mergeHistory(previousReport, currentHistoryEntry) {
+  const existingHistory = Array.isArray(previousReport?.history) ? previousReport.history : [];
+  const mergedHistory = [...existingHistory, currentHistoryEntry];
+
+  if (mergedHistory.length <= HISTORY_LIMIT) {
+    return mergedHistory;
+  }
+
+  return mergedHistory.slice(mergedHistory.length - HISTORY_LIMIT);
+}
+
+async function runWeeklyGovernanceReport() {
+  const qualityTrendState = loadQualityTrendReport();
+  const qualityTrendReport = qualityTrendState.report;
+
+  const skillTrustSignals = await collectSkillTrustSignals();
+  const commitSignals = collectCommitSignals(WEEKLY_WINDOW_DAYS);
+  const blockers = buildBlockers(qualityTrendReport, skillTrustSignals, commitSignals);
+
+  const weeklyReportSnapshot = {
+    generatedAt: new Date().toISOString(),
+    reportName: 'weekly-governance-report',
+    methodology: {
+      qualityTrendSource: qualityTrendState.source,
+      qualityTrendGeneratedAt: qualityTrendState.freshness,
+      commitWindowDays: WEEKLY_WINDOW_DAYS,
+      requiredVerifiedDomains: Array.from(REQUIRED_VERIFIED_DOMAINS),
+    },
+    qualitySignals: {
+      governanceHealth: {
+        availableGateCount: qualityTrendReport?.governanceHealth?.availableGateCount ?? null,
+        passedGateCount: qualityTrendReport?.governanceHealth?.passedGateCount ?? null,
+        gatePassRatePercent: qualityTrendReport?.governanceHealth?.gatePassRatePercent ?? null,
+      },
+      rejectionCategories: Array.isArray(qualityTrendReport?.rejectionCategories)
+        ? qualityTrendReport.rejectionCategories
+        : [],
+      tokenEfficiency: qualityTrendReport?.tokenEfficiency || null,
+    },
+    skillTrust: skillTrustSignals,
+    commitSignals,
+    releaseReadiness: {
+      isReady: blockers.length === 0,
+      blockers,
+      summary: blockers.length === 0
+        ? 'Weekly governance posture is ready for maintenance releases.'
+        : 'Weekly governance posture is blocked by unresolved readiness signals.',
+    },
+    artifact: {
+      path: REPORT_PATH,
+      writeMode: isStdoutOnlyMode ? 'stdout-only' : 'stdout-and-file',
+    },
+  };
+
+  const previousReport = readJsonOrNull(REPORT_PATH);
+  const history = mergeHistory(previousReport, buildHistoryEntry(weeklyReportSnapshot));
+  const weeklyReport = {
+    ...weeklyReportSnapshot,
+    history,
+  };
+
+  if (!isStdoutOnlyMode) {
+    await fs.mkdir(dirname(REPORT_PATH), { recursive: true });
+    await fs.writeFile(REPORT_PATH, JSON.stringify(weeklyReport, null, 2) + '\n', 'utf8');
+  }
+
+  return weeklyReport;
+}
+
+runWeeklyGovernanceReport()
+  .then((weeklyReport) => {
+    console.log(JSON.stringify(weeklyReport, null, 2));
+  })
+  .catch((reportError) => {
+    const errorMessage = reportError instanceof Error ? reportError.message : String(reportError);
+    console.error(`Weekly governance report failed: ${errorMessage}`);
+    process.exit(1);
+  });

package/scripts/quality-trend-report.mjs

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+
+/**
+ * quality-trend-report.mjs
+ *
+ * Generates a machine-readable quality trend artifact that summarizes
+ * governance gate pass rates, rejection categories, rollback frequency,
+ * and token-efficiency signals.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_FILE_PATH = fileURLToPath(import.meta.url);
+const SCRIPT_DIR = dirname(SCRIPT_FILE_PATH);
+const REPOSITORY_ROOT = resolve(SCRIPT_DIR, '..');
+const REPORT_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'quality-trend-report.json');
+const TOKEN_BENCHMARK_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'token-optimization-benchmark.json');
+const ARGUMENT_FLAGS = new Set(process.argv.slice(2));
+const isStdoutOnlyMode = ARGUMENT_FLAGS.has('--stdout-only');
+const MAX_SNAPSHOT_HISTORY = 30;
+const ROLLBACK_WINDOW_DAYS = 30;
+
+function runJsonScript(scriptRelativePath) {
+  const absoluteScriptPath = join(REPOSITORY_ROOT, scriptRelativePath);
+  const commandResult = spawnSync('node', [absoluteScriptPath], {
+    cwd: REPOSITORY_ROOT,
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024 * 10,
+  });
+
+  const standardOutput = (commandResult.stdout || '').trim();
+  const standardError = (commandResult.stderr || '').trim();
+  const exitCode = typeof commandResult.status === 'number' ? commandResult.status : 1;
+
+  if (!standardOutput) {
+    return {
+      scriptPath: scriptRelativePath,
+      exitCode,
+      parsedReport: null,
+      parseError: 'Script produced no stdout JSON payload',
+      stderr: standardError,
+    };
+  }
+
+  try {
+    const parsedReport = JSON.parse(standardOutput);
+    return {
+      scriptPath: scriptRelativePath,
+      exitCode,
+      parsedReport,
+      parseError: null,
+      stderr: standardError,
+    };
+  } catch (jsonParseError) {
+    const errorMessage = jsonParseError instanceof Error ? jsonParseError.message : String(jsonParseError);
+    return {
+      scriptPath: scriptRelativePath,
+      exitCode,
+      parsedReport: null,
+      parseError: errorMessage,
+      stderr: standardError,
+    };
+  }
+}
+
+function readJsonFileOrNull(filePath) {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function summarizeGateExecution(gateExecutionResults) {
+  const gateSummaries = gateExecutionResults.map((gateExecutionResult) => {
+    const gateReport = gateExecutionResult.parsedReport;
+    return {
+      scriptPath: gateExecutionResult.scriptPath,
+      gateName: gateReport?.gateName || gateReport?.reportName || gateExecutionResult.scriptPath,
+      exitCode: gateExecutionResult.exitCode,
+      passed: typeof gateReport?.passed === 'boolean' ? gateReport.passed : false,
+      parseError: gateExecutionResult.parseError,
+      failureCount: typeof gateReport?.failureCount === 'number' ? gateReport.failureCount : null,
+      generatedAt: gateReport?.generatedAt || null,
+    };
+  });
+
+  const availableGateCount = gateSummaries.length;
+  const passedGateCount = gateSummaries.filter((gateSummary) => gateSummary.passed).length;
+  const gatePassRatePercent = availableGateCount === 0
+    ? 0
+    : Number(((passedGateCount / availableGateCount) * 100).toFixed(2));
+
+  return {
+    gateSummaries,
+    availableGateCount,
+    passedGateCount,
+    gatePassRatePercent,
+  };
+}
+
+function collectRejectionCategories(gateExecutionResults) {
+  const rejectionCategoryMap = new Map();
+
+  for (const gateExecutionResult of gateExecutionResults) {
+    const gateReport = gateExecutionResult.parsedReport;
+    const gateName = gateReport?.gateName || gateReport?.reportName || gateExecutionResult.scriptPath;
+    const gateResults = Array.isArray(gateReport?.results) ? gateReport.results : [];
+
+    for (const checkResult of gateResults) {
+      if (checkResult?.passed === true) {
+        continue;
+      }
+
+      const checkName = typeof checkResult?.checkName === 'string' ? checkResult.checkName : 'unknown-check';
+      const existingCategory = rejectionCategoryMap.get(checkName) || {
+        checkName,
+        count: 0,
+        gates: new Set(),
+      };
+
+      existingCategory.count += 1;
+      existingCategory.gates.add(gateName);
+      rejectionCategoryMap.set(checkName, existingCategory);
+    }
+  }
+
+  return Array.from(rejectionCategoryMap.values())
+    .map((rejectionCategory) => ({
+      checkName: rejectionCategory.checkName,
+      count: rejectionCategory.count,
+      gates: Array.from(rejectionCategory.gates),
+    }))
+    .sort((firstCategory, secondCategory) => secondCategory.count - firstCategory.count);
+}
+
+function calculateRollbackFrequencySnapshot() {
+  const gitLogResult = spawnSync('git', ['log', `--since=${ROLLBACK_WINDOW_DAYS}.days`, '--pretty=format:%s'], {
+    cwd: REPOSITORY_ROOT,
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024,
+  });
+
+  if (gitLogResult.status !== 0) {
+    return {
+      windowDays: ROLLBACK_WINDOW_DAYS,
+      commitCount: 0,
+      rollbackCommitCount: 0,
+      rollbackFrequencyPercent: null,
+      source: 'git-log',
+      error: (gitLogResult.stderr || 'Failed to read git log').trim(),
+    };
+  }
+
+  const commitSubjects = (gitLogResult.stdout || '')
+    .split(/\r?\n/u)
+    .map((subjectLine) => subjectLine.trim())
+    .filter((subjectLine) => subjectLine.length > 0);
+
+  const rollbackCommitCount = commitSubjects.filter((subjectLine) => /rollback/i.test(subjectLine)).length;
+  const commitCount = commitSubjects.length;
+  const rollbackFrequencyPercent = commitCount === 0
+    ? 0
+    : Number(((rollbackCommitCount / commitCount) * 100).toFixed(2));
+
+  return {
+    windowDays: ROLLBACK_WINDOW_DAYS,
+    commitCount,
+    rollbackCommitCount,
+    rollbackFrequencyPercent,
+    source: 'git-log',
+    error: null,
+  };
+}
+
+function summarizeTokenBenchmark() {
+  const tokenBenchmarkReport = readJsonFileOrNull(TOKEN_BENCHMARK_PATH);
+  if (!tokenBenchmarkReport) {
+    return {
+      isAvailable: false,
+      generatedAt: null,
+      averageNativeSavingsPercent: null,
+      averageRtkSavingsPercent: null,
+      scenarioCount: 0,
+    };
+  }
+
+  return {
+    isAvailable: true,
+    generatedAt: tokenBenchmarkReport.generatedAt || null,
+    averageNativeSavingsPercent: tokenBenchmarkReport.summary?.averageNativeSavingsPercent ?? null,
+    averageRtkSavingsPercent: tokenBenchmarkReport.summary?.averageRtkSavingsPercent ?? null,
+    scenarioCount: Array.isArray(tokenBenchmarkReport.scenarios) ? tokenBenchmarkReport.scenarios.length : 0,
+  };
+}
+
+function loadPreviousTrendHistory() {
+  const previousReport = readJsonFileOrNull(REPORT_PATH);
+  if (!previousReport || !Array.isArray(previousReport.history)) {
+    return [];
+  }
+
+  return previousReport.history;
+}
+
+function buildHistoryEntry(currentSnapshot) {
+  return {
+    generatedAt: currentSnapshot.generatedAt,
+    gatePassRatePercent: currentSnapshot.governanceHealth.gatePassRatePercent,
+    passedGateCount: currentSnapshot.governanceHealth.passedGateCount,
+    availableGateCount: currentSnapshot.governanceHealth.availableGateCount,
+    rollbackFrequencyPercent: currentSnapshot.rollbackSignals.rollbackFrequencyPercent,
+    averageNativeSavingsPercent: currentSnapshot.tokenEfficiency.averageNativeSavingsPercent,
+    averageRtkSavingsPercent: currentSnapshot.tokenEfficiency.averageRtkSavingsPercent,
+    rejectionCategoryCount: currentSnapshot.rejectionCategories.length,
+  };
+}
+
+function mergeHistory(previousHistoryEntries, currentHistoryEntry) {
+  const mergedHistoryEntries = [...previousHistoryEntries, currentHistoryEntry];
+  if (mergedHistoryEntries.length <= MAX_SNAPSHOT_HISTORY) {
+    return mergedHistoryEntries;
+  }
+
+  return mergedHistoryEntries.slice(mergedHistoryEntries.length - MAX_SNAPSHOT_HISTORY);
+}
+
+async function runQualityTrendReport() {
+  const releaseGateExecution = runJsonScript('scripts/release-gate.mjs');
+  const benchmarkGateExecution = runJsonScript('scripts/benchmark-gate.mjs');
+  const benchmarkIntelligenceExecution = runJsonScript('scripts/benchmark-intelligence.mjs');
+  const gateExecutionResults = [releaseGateExecution, benchmarkGateExecution, benchmarkIntelligenceExecution];
+
+  const governanceHealth = summarizeGateExecution(gateExecutionResults);
+  const rejectionCategories = collectRejectionCategories(gateExecutionResults);
+  const rollbackSignals = calculateRollbackFrequencySnapshot();
+  const tokenEfficiency = summarizeTokenBenchmark();
+
+  const qualityTrendSnapshot = {
+    generatedAt: new Date().toISOString(),
+    reportName: 'quality-trend-report',
+    methodology: {
+      gateSources: gateExecutionResults.map((gateExecutionResult) => gateExecutionResult.scriptPath),
+      rollbackSource: 'git log commit subjects within 30-day window',
+      tokenSource: '.agent-context/state/token-optimization-benchmark.json',
+    },
+    governanceHealth,
+    rejectionCategories,
+    rollbackSignals,
+    tokenEfficiency,
+    artifact: {
+      path: REPORT_PATH,
+      writeMode: isStdoutOnlyMode ? 'stdout-only' : 'stdout-and-file',
+    },
+  };
+
+  const previousHistoryEntries = loadPreviousTrendHistory();
+  const currentHistoryEntry = buildHistoryEntry(qualityTrendSnapshot);
+  const history = mergeHistory(previousHistoryEntries, currentHistoryEntry);
+  const qualityTrendReport = {
+    ...qualityTrendSnapshot,
+    history,
+  };
+
+  if (!isStdoutOnlyMode) {
+    await fs.mkdir(dirname(REPORT_PATH), { recursive: true });
+    await fs.writeFile(REPORT_PATH, JSON.stringify(qualityTrendReport, null, 2) + '\n', 'utf8');
+  }
+
+  return qualityTrendReport;
+}
+
+runQualityTrendReport()
+  .then((qualityTrendReport) => {
+    console.log(JSON.stringify(qualityTrendReport, null, 2));
+  })
+  .catch((qualityTrendError) => {
+    const errorMessage = qualityTrendError instanceof Error ? qualityTrendError.message : String(qualityTrendError);
+    console.error(`Quality trend report failed: ${errorMessage}`);
+    process.exit(1);
+  });

package/scripts/release-gate.mjs

@@ -10,6 +10,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { execFileSync } from 'node:child_process';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -26,6 +27,15 @@ const REQUIRED_SKILL_DOMAINS = [
   'distribution',
   'review-quality',
 ];
+const FRONTEND_PARITY_CHECKLIST_PATH = '.agent-context/review-checklists/frontend-skill-parity.md';
+const FRONTEND_AUDIT_SCRIPT_PATH = 'scripts/frontend-usability-audit.mjs';
+const REQUIRED_FRONTEND_PARITY_SNIPPETS = [
+  'Architecture and Composition',
+  'Interaction and Motion',
+  'Accessibility and Responsiveness',
+  'UX Narrative and Conversion Clarity',
+  'Release Evidence',
+];
 
 function readText(relativeFilePath) {
   const absolutePath = resolve(REPOSITORY_ROOT, relativeFilePath);
@@ -124,6 +134,8 @@ function runReleaseGate() {
     'docs/v1.8-operations-playbook.md',
     '.github/workflows/release-gate.yml',
     '.github/workflows/sbom-compliance.yml',
+    '.github/workflows/governance-weekly-report.yml',
+    'scripts/governance-weekly-report.mjs',
   ];
 
   for (const requiredEnterpriseFile of requiredEnterpriseFiles) {
@@ -188,6 +200,51 @@ function runReleaseGate() {
     );
   }
 
+  const frontendParityChecklistContent = readText(FRONTEND_PARITY_CHECKLIST_PATH);
+  if (!frontendParityChecklistContent) {
+    pushResult(results, false, 'frontend-parity-checklist-exists', `Missing ${FRONTEND_PARITY_CHECKLIST_PATH}`);
+  } else {
+    pushResult(results, true, 'frontend-parity-checklist-exists', `${FRONTEND_PARITY_CHECKLIST_PATH} is present`);
+
+    const missingFrontendParitySnippets = REQUIRED_FRONTEND_PARITY_SNIPPETS.filter(
+      (requiredSnippet) => !frontendParityChecklistContent.includes(requiredSnippet)
+    );
+
+    if (missingFrontendParitySnippets.length === 0) {
+      pushResult(results, true, 'frontend-parity-checklist-coverage', 'Frontend parity checklist sections are complete');
+    } else {
+      pushResult(
+        results,
+        false,
+        'frontend-parity-checklist-coverage',
+        `Missing frontend parity checklist sections: ${missingFrontendParitySnippets.join(', ')}`
+      );
+    }
+  }
+
+  try {
+    const frontendAuditRawOutput = execFileSync('node', [FRONTEND_AUDIT_SCRIPT_PATH], {
+      cwd: REPOSITORY_ROOT,
+      encoding: 'utf8',
+      maxBuffer: 1024 * 1024,
+    });
+    const frontendAuditReport = JSON.parse(frontendAuditRawOutput);
+
+    if (frontendAuditReport.passed === true) {
+      pushResult(results, true, 'frontend-usability-audit', 'frontend-usability-audit report passed');
+    } else {
+      const failureDetails = Array.isArray(frontendAuditReport.failures)
+        ? frontendAuditReport.failures.join('; ')
+        : 'Unknown frontend audit failures';
+      pushResult(results, false, 'frontend-usability-audit', `frontend-usability-audit reported failures: ${failureDetails}`);
+    }
+  } catch (frontendAuditError) {
+    const frontendAuditErrorMessage = frontendAuditError instanceof Error
+      ? frontendAuditError.message
+      : 'Unknown frontend audit execution error';
+    pushResult(results, false, 'frontend-usability-audit', `Failed to execute frontend usability audit: ${frontendAuditErrorMessage}`);
+  }
+
   const failureCount = results.filter((checkResult) => !checkResult.passed).length;
   const releaseGateReport = {
     generatedAt: new Date().toISOString(),