@songforgeai/fidelity-standard

The Fidelity Standard — seven-component composite for measuring AI lyric fidelity.

v0.1.0 — in public RFC comment through 2026-05-26 (RFC-0010).

Companion to @songforgeai/scoring-rubric. That package ships the 12-metric quality rubric. This package ships the orthogonal seven-component fidelity composite: did the lyric serve the brief?

What this is

The Fidelity Standard answers a question the Lyric Scoring Standard doesn't: when an AI lyric tool generates a song against a brief, did the system write the song the user asked for?

That's a different question from "is the song good?" A song can score 90 on quality and still be the wrong song — the failure mode Sacred Accident #17 names in the SongForgeAI codebase.

Seven components, weighted into a 0-100 composite:

| Weight | Component | Question | |---|---|---| | 30% | Premise match | Did the lyric serve the named premise? | | 25% | Anchor coverage | Did each required detail land in a vivid line? | | 15% | Structure compliance | Does the section map match what was asked? | | 15% | Style constraints | Were the style rules honored? | | 5% | Forbidden language | Did the lyric avoid the banned words? | | 5% | Chorus evolution | Did the chorus actually shift across the song? | | 5% | Earned transcendence | Did a V1 image return with transformed meaning? |

Premise + anchors = 55% load-bearing. Read the full standard for the methodology, formulas, and calibration.

Install

npm install @songforgeai/fidelity-standard

Use

TypeScript

import {
  STANDARD,
  VERSION,
  computeFidelityGrade,
  computeFidelityBucket,
  computeBriefComplexity,
  applyConstraintMultiplier,
} from '@songforgeai/fidelity-standard';

console.log(VERSION); // "0.1.0"

const grade = computeFidelityGrade(85);     // "B+"
const bucket = computeFidelityBucket(85, 8); // "primary" (heavy brief)
const complexity = computeBriefComplexity({
  anchors: ['kitchen at midnight', 'her mother on the phone'],
  styleConstraints: ['sensory-only'],
  structure: ['verse', 'chorus', 'verse', 'chorus'],
  premise: 'a song about the patterns we cannot break',
});
console.log(complexity); // 5 (anchors:2 + style:1 + structure:1 + premise>=40:1)

const finalScore = applyConstraintMultiplier(95, 'strict');
console.log(finalScore); // 90 (× 0.95)

// Inspect the canonical components + their weights:
for (const c of STANDARD.components) {
  console.log(`${c.label}: ${c.weight * 100}% — ${c.question}`);
}

JSON-only (any language)

import standard from '@songforgeai/fidelity-standard/standard.json';

console.log(standard.version);          // "0.1.0"
console.log(standard.components.length); // 7

What this package does NOT include

This is a standard, not an implementation. The package ships:

• The canonical JSON (version, components, weights, formulas, grade scale, UX buckets, RFC pointers)
• TypeScript types
• Pure-data helpers (computeFidelityGrade, computeFidelityBucket, computeBriefComplexity, applyConstraintMultiplier)

It does NOT ship:

• A premise-match Haiku judge (operator-tier infrastructure — see the SongForgeAI canonical repo for the reference implementation)
• The seven audit modules (regex / vocabulary / heuristic scanners)
• The orchestrator that combines them

If you want to score lyrics against the Fidelity Standard programmatically, two paths:

1. Use the SongForgeAI API: POST /api/v1/fidelity (auth-gated). See /scoring/standard/fidelity for the contract.
2. Implement the standard yourself: this package's JSON + types describe everything you need. The canonical reference implementation lives at github.com/torgin-dev/songforge-ai under MIT license.

Licensing

The standard itself (the JSON document, the methodology, the calibration) is licensed under CC BY 4.0. Use it, fork it, build on it. Attribution required:

Nigro, T. (2026). The Fidelity Standard v0.1.0. SongForgeAI. https://songforgeai.com/scoring/standard/fidelity. CC BY 4.0.

The TypeScript code in this package (helpers, types) is licensed under MIT for maximum integration freedom.

Versioning

• v0.1.x — initial public draft. Open for public comment via RFC-0010 through 2026-05-26.
• v1.0.0 — first stable release. Ships after RFC-0010 closes with any community-incorporated changes.
• v1.x.x — minor / patch updates. Any breaking change to the wire shape requires a new RFC.

The package version tracks the standard version exactly.

RFC-0010 — Open questions

The v0.1.0 numbers are operator-locked but NOT settled. Five questions stayed deliberately open:

1. Is the 30/25 split between premise + anchors the right calibration?
2. Should strict mode cap at 0.95 or at 0.90?
3. Is the 'primary' bucket threshold (complexity ≥ 7) the right edge?
4. Should chorus evolution + earned transcendence weigh more than 5% each?
5. What's the right semantics for an N/A verdict — abstain or count negatively?

If you have a view on any of these, email [email protected] with subject "RFC-0010 comment" before the window closes.

Related

• @songforgeai/scoring-rubric — the quality rubric this package's standard is orthogonal to
• The Lyric Scoring Standard v1.0 — the published 12-metric rubric
• Introducing the Fidelity Standard v0.1.0 — launch essay
• SA#17: The Orthogonal Question — songwriter explainer