@holdyourvoice/hyv 3.6.1 → 4.0.0

package/dist/rewrite-task.js

@@ -9,47 +9,32 @@ const MAX_REPLACEMENT_CHARACTERS = 10_000;
 function isFailure(value) {
     return typeof value === 'object' && value !== null && 'code' in value;
 }
-function parseResponse(value) {
-    const raw = typeof value === 'string' ? parseResponseJson(value) : value;
-    if (isFailure(raw))
-        return raw;
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
-        return failure('invalid_response_shape', 'Response must be an object.');
-    const response = raw;
-    if (typeof response.taskFingerprint !== 'string' || response.taskFingerprint.length !== 64)
-        return failure('invalid_response_shape', 'Response must include the task fingerprint.', 'taskFingerprint');
-    if (response.mode === 'REBUILD')
-        return failure('rebuild_response_on_edit_task', 'Rebuild responses cannot satisfy edit tasks.', 'mode');
-    if (response.mode === 'SHIP' && response.version === '1') {
-        return { version: '1', mode: 'SHIP', taskFingerprint: response.taskFingerprint };
-    }
-    if (response.version === '2') {
-        if (!Array.isArray(response.operations))
-            return failure('invalid_response_shape', 'Version 2 responses require an operations array.', 'operations');
-        if (response.operations.length > MAX_REPLACEMENTS)
-            return failure('invalid_response_shape', `Response may include at most ${MAX_REPLACEMENTS} replacements.`, 'operations');
-        for (const [index, operation] of response.operations.entries()) {
-            if (!operation || typeof operation !== 'object' || !Number.isInteger(operation.startSentenceId) || !Number.isInteger(operation.endSentenceId) || typeof operation.text !== 'string') {
-                return failure('invalid_response_shape', 'Every operation requires integer startSentenceId, endSentenceId, and string text.', `operations[${index}]`);
-            }
-            if (operation.endSentenceId < operation.startSentenceId)
-                return failure('noncontiguous_range', 'A range must be inclusive and contiguous.', `operations[${index}]`);
-            if (operation.text.length > MAX_REPLACEMENT_CHARACTERS)
-                return failure('invalid_replacement_text', `Replacement text must contain at most ${MAX_REPLACEMENT_CHARACTERS} characters.`, `operations[${index}].text`);
+function parseRangeResponse(response) {
+    if (!Array.isArray(response.operations))
+        return failure('invalid_response_shape', 'Version 2 responses require an operations array.', 'operations');
+    if (response.operations.length > MAX_REPLACEMENTS)
+        return failure('invalid_response_shape', `Response may include at most ${MAX_REPLACEMENTS} replacements.`, 'operations');
+    for (const [index, operation] of response.operations.entries()) {
+        if (!operation || typeof operation !== 'object' || !Number.isInteger(operation.startSentenceId) || !Number.isInteger(operation.endSentenceId) || typeof operation.text !== 'string') {
+            return failure('invalid_response_shape', 'Every operation requires integer startSentenceId, endSentenceId, and string text.', `operations[${index}]`);
         }
-        if (response.hygieneOperations !== undefined) {
-            if (!Array.isArray(response.hygieneOperations))
-                return failure('invalid_response_shape', 'Hygiene operations must be an array.', 'hygieneOperations');
-            for (const [index, operation] of response.hygieneOperations.entries()) {
-                if (!operation || !Number.isInteger(operation.start) || !Number.isInteger(operation.end) || typeof operation.text !== 'string' || operation.end < operation.start) {
-                    return failure('invalid_response_shape', 'Every hygiene operation requires integer start, end, and string text.', `hygieneOperations[${index}]`);
-                }
+        if (operation.endSentenceId < operation.startSentenceId)
+            return failure('noncontiguous_range', 'A range must be inclusive and contiguous.', `operations[${index}]`);
+        if (operation.text.length > MAX_REPLACEMENT_CHARACTERS)
+            return failure('invalid_replacement_text', `Replacement text must contain at most ${MAX_REPLACEMENT_CHARACTERS} characters.`, `operations[${index}].text`);
+    }
+    if (response.hygieneOperations !== undefined) {
+        if (!Array.isArray(response.hygieneOperations))
+            return failure('invalid_response_shape', 'Hygiene operations must be an array.', 'hygieneOperations');
+        for (const [index, operation] of response.hygieneOperations.entries()) {
+            if (!operation || !Number.isInteger(operation.start) || !Number.isInteger(operation.end) || typeof operation.text !== 'string' || operation.end < operation.start) {
+                return failure('invalid_response_shape', 'Every hygiene operation requires integer start, end, and string text.', `hygieneOperations[${index}]`);
             }
         }
-        return response;
     }
-    if (response.version !== '1')
-        return failure('invalid_response_version', 'Response version must be "1" or "2".', 'version');
+    return response;
+}
+function parseReplacements(response) {
     if (!Array.isArray(response.replacements))
         return failure('invalid_response_shape', 'Response replacements must be an array.', 'replacements');
     if (response.replacements.length > MAX_REPLACEMENTS)
@@ -64,27 +49,48 @@ function parseResponse(value) {
     }
     return response;
 }
-function repairStringifiedReplacements(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return { value };
-    const raw = value;
-    if (typeof raw.replacements !== 'string')
-        return { value };
-    try {
-        const replacements = JSON.parse(raw.replacements);
-        if (!Array.isArray(replacements))
-            return { value };
-        return { value: { ...raw, replacements }, adapterId: 'stringified_replacements_v1' };
+function parseResponse(value) {
+    const raw = typeof value === 'string' ? parseResponseJson(value) : value;
+    if (isFailure(raw))
+        return raw;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return failure('invalid_response_shape', 'Response must be an object.');
+    const response = raw;
+    if (typeof response.taskFingerprint !== 'string' || response.taskFingerprint.length !== 64)
+        return failure('invalid_response_shape', 'Response must include the task fingerprint.', 'taskFingerprint');
+    if (response.mode === 'REBUILD')
+        return failure('rebuild_response_on_edit_task', 'Rebuild responses cannot satisfy edit tasks.', 'mode');
+    if (response.mode === 'SHIP' && response.version === '1')
+        return { version: '1', mode: 'SHIP', taskFingerprint: response.taskFingerprint };
+    if (response.version === '2')
+        return parseRangeResponse(response);
+    if (response.version !== '1')
+        return failure('invalid_response_version', 'Response version must be "1" or "2".', 'version');
+    return parseReplacements(response);
+}
+function decodeResponse(raw) {
+    const source = typeof raw === 'string' ? parseResponseJson(raw) : raw;
+    const response = isFailure(source) ? source : parseResponse(source);
+    if (isFailure(response) && response.code === 'invalid_json' && typeof raw === 'string') {
+        const fenced = raw.match(/^```json\s*\n([\s\S]*?)\n```\s*$/i);
+        if (fenced)
+            return { response: parseResponse(fenced[1]), adapterIds: ['fenced_json_v1'] };
     }
-    catch {
-        return { value };
+    if (isFailure(response) && response.code === 'invalid_response_shape' && source && typeof source === 'object' && !Array.isArray(source)) {
+        const value = source;
+        if (typeof value.replacements === 'string') {
+            let replacements;
+            try {
+                replacements = JSON.parse(value.replacements);
+            }
+            catch {
+                return { response, adapterIds: [] };
+            }
+            if (Array.isArray(replacements))
+                return { response: parseResponse({ ...value, replacements }), adapterIds: ['stringified_replacements_v1'] };
+        }
     }
-}
-function repairFencedJson(value) {
-    if (typeof value !== 'string')
-        return { value };
-    const match = value.match(/^```json\s*\n([\s\S]*?)\n```\s*$/i);
-    return match ? { value: match[1], adapterId: 'fenced_json_v1' } : { value };
+    return { response, adapterIds: [] };
 }
 export function prepareRewriteTask(draft, profile, copySpec, writingBrief, authorizedSentenceIds = []) {
     const result = analyze(draft, profile, writingBrief);
@@ -135,12 +141,7 @@ export function applyShip(task) {
     };
 }
 export function applyRewriteResponse(task, raw) {
-    const source = typeof raw === 'string' ? parseResponseJson(raw) : raw;
-    const parsed = isFailure(source) ? source : parseResponse(source);
-    const fenced = isFailure(parsed) && parsed.code === 'invalid_json' ? repairFencedJson(raw) : { value: source };
-    const repaired = isFailure(parsed) && parsed.code === 'invalid_response_shape' ? repairStringifiedReplacements(source) : fenced;
-    const response = repaired.adapterId ? parseResponse(repaired.value) : parsed;
-    const adapterIds = repaired.adapterId ? [repaired.adapterId] : [];
+    const { response, adapterIds } = decodeResponse(raw);
     if (isFailure(response))
         return rejected(task, raw, [response], adapterIds);
     if (response.taskFingerprint !== task.fingerprint)
@@ -205,10 +206,10 @@ function applyRangeResponse(task, response, raw, adapterIds) {
     for (const operation of [...(response.hygieneOperations ?? [])].sort((left, right) => right.start - left.start)) {
         candidate = `${candidate.slice(0, operation.start)}${operation.text}${candidate.slice(operation.end)}`;
     }
-    const mapped = sentences(candidate);
+    const mapped = new Map(sentences(candidate).map((sentence) => [sentence.index, sentence]));
     for (const operation of [...response.operations].reverse()) {
-        const start = mapped.find((sentence) => sentence.index === operation.startSentenceId);
-        const end = mapped.find((sentence) => sentence.index === operation.endSentenceId);
+        const start = mapped.get(operation.startSentenceId);
+        const end = mapped.get(operation.endSentenceId);
         if (!start || !end)
             return rejected(task, raw, [failure('unknown_sentence_id', 'Range sentenceId is not in this task.', 'operations')], adapterIds);
         candidate = `${candidate.slice(0, start.start)}${operation.text}${candidate.slice(end.end)}`;

package/dist/rule-allowances.js

@@ -5,13 +5,6 @@ const RULE_MATCHERS = {
     'punct.en-dash': /–/u,
     'format.curly-quotes': /[“”]/u,
 };
-function evidenceDigest(ruleId, samples) {
-    const evidence = samples
-        .filter((sample) => RULE_MATCHERS[ruleId].test(sample))
-        .map((sample) => sample.replace(/\s+/gu, ' ').trim())
-        .sort();
-    return createHash('sha256').update(JSON.stringify({ ruleId, evidence })).digest('hex');
-}
 /**
  * Returns only non-verbatim evidence for stylistic exceptions shown in two or
  * more author-owned samples. Callers add the result to a signed Profile v3.
@@ -19,9 +12,12 @@ function evidenceDigest(ruleId, samples) {
 export function deriveRuleAllowances(samples) {
     const allowances = {};
     for (const ruleId of SAMPLE_ALLOWANCE_RULE_IDS) {
-        const count = samples.filter((sample) => RULE_MATCHERS[ruleId].test(sample)).length;
-        if (count >= 2)
-            allowances[ruleId] = { sampleCount: count, evidenceDigest: evidenceDigest(ruleId, samples) };
+        const matched = samples.filter((sample) => RULE_MATCHERS[ruleId].test(sample));
+        if (matched.length < 2)
+            continue;
+        const evidence = matched.map((sample) => sample.replace(/\s+/gu, ' ').trim()).sort();
+        const evidenceDigest = createHash('sha256').update(JSON.stringify({ ruleId, evidence })).digest('hex');
+        allowances[ruleId] = { sampleCount: matched.length, evidenceDigest };
     }
     return allowances;
 }

package/dist/semantic-review.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { canonicalJson } from './canonical-json.js';
 import { verifyApprovalCapability } from './approval-capability.js';
-import { exactKeys as exact, isPlainObject as plain } from './internal.js';
+import { exactKeys as exact, isPlainObject as plain, verificationMatchesBinding } from './internal.js';
 const violations = new Set(['action_change', 'dropped_object', 'unsupported_claim', 'constraint_weakened', 'clarity_regression']);
 const HEX = /^[a-f0-9]{64}$/;
 const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
@@ -94,7 +94,7 @@ export function createInitialLifecycleArtifact(task, deterministic) {
     const { taskFingerprint, ...taskBase } = task;
     const { artifactFingerprint, ...deterministicBase } = deterministic;
     const expectedDeterministicFingerprint = createHash('sha256').update(`hyv:deterministic-verification:v1\0${canonicalJson(deterministicBase)}`).digest('hex');
-    if (taskFingerprint !== hash('hyv:semantic-task:v1', taskBase) || !deterministic.passed || artifactFingerprint !== expectedDeterministicFingerprint || deterministic.artifactFingerprint !== task.binding.deterministicArtifactFingerprint || deterministic.sourceHash !== task.binding.sourceHash || deterministic.candidateHash !== task.binding.candidateHash || deterministic.profileId !== task.binding.profileId || deterministic.profileRevisionDigest !== task.binding.profileRevisionDigest || deterministic.rulesetVersion !== task.binding.rulesetVersion)
+    if (taskFingerprint !== hash('hyv:semantic-task:v1', taskBase) || !deterministic.passed || artifactFingerprint !== expectedDeterministicFingerprint || !verificationMatchesBinding(deterministic, task.binding))
         throw new Error('Lifecycle creation requires its bound passed deterministic verification artifact.');
     return artifact({ version: '1', status: 'needs_semantic_review', transitionFingerprint: hash('hyv:lifecycle-initial:v1', { binding: task.binding, semanticPolicy: task.policy }), binding: task.binding, semanticPolicy: task.policy, semanticTaskFingerprint: task.taskFingerprint, semanticEvidenceScopeFingerprint: hash('hyv:semantic-evidence-scope:v1', task.evidenceScope), verdictFingerprints: [] });
 }
@@ -120,6 +120,72 @@ function normalizeAction(value) {
     }
     return undefined;
 }
+function nextArtifact(current, transitionFingerprint, status, verdictFingerprints, extra = {}) {
+    return { ok: true, artifact: artifact({
+            version: '1', status, parentArtifactFingerprint: current.artifactFingerprint,
+            transitionFingerprint, binding: current.binding, semanticPolicy: current.semanticPolicy,
+            semanticTaskFingerprint: current.semanticTaskFingerprint,
+            semanticEvidenceScopeFingerprint: current.semanticEvidenceScopeFingerprint,
+            verdictFingerprints, ...extra,
+        }) };
+}
+function submitReview(current, action, context, transitionFingerprint) {
+    if (current.status !== 'needs_semantic_review')
+        return fail('out_of_order_transition');
+    const required = current.semanticPolicy === 'normal' ? 1 : 3;
+    if (action.verdicts.length !== required)
+        return fail('invalid_verdict_count');
+    const ids = action.verdicts.map((verdict) => verdict.evaluatorId);
+    if (new Set(ids).size !== ids.length)
+        return fail('duplicate_evaluator');
+    const authorized = current.semanticPolicy === 'normal'
+        ? context.authorizedSemanticEvaluatorIds.normal
+        : context.authorizedSemanticEvaluatorIds.highAssurance;
+    if (current.semanticPolicy === 'high_assurance' && new Set(authorized).size < 3)
+        return fail('invalid_verdict_count');
+    if (ids.some((id) => !authorized.includes(id)))
+        return fail('evaluator_not_authorized');
+    for (const verdict of action.verdicts) {
+        if (action.taskFingerprint !== current.semanticTaskFingerprint || verdict.taskFingerprint !== action.taskFingerprint)
+            return fail('task_fingerprint_mismatch');
+        if (!same(verdict.binding, current.binding))
+            return fail('invalid_binding');
+        if (verdict.judgmentType !== 'semantic' || hash('hyv:semantic-evidence-scope:v1', verdict.evidenceScope) !== current.semanticEvidenceScopeFingerprint)
+            return fail('evidence_scope_mismatch');
+        if ((verdict.approved && verdict.violations.length) || (!verdict.approved && !verdict.violations.length))
+            return fail('contradictory_verdict');
+    }
+    const fingerprints = action.verdicts.map((verdict) => hash('hyv:semantic-verdict:v1', verdict));
+    const approvals = action.verdicts.filter((verdict) => verdict.approved).length;
+    if (approvals === required)
+        return nextArtifact(current, transitionFingerprint, 'ready_for_human_review', fingerprints);
+    return nextArtifact(current, transitionFingerprint, 'needs_escalation', fingerprints, {
+        reason: approvals === 0 ? 'semantic_rejection' : 'semantic_disagreement',
+    });
+}
+function finalizeReview(current, action, context, transitionFingerprint) {
+    if (current.status !== 'ready_for_human_review')
+        return fail('out_of_order_transition');
+    const finalization = action.finalization;
+    if (finalization.parentArtifactFingerprint !== current.artifactFingerprint || !same(finalization.binding, current.binding) || finalization.judgmentType !== 'human_finalization' || finalization.evidenceScope.kind !== 'candidate')
+        return fail('invalid_binding');
+    if (!context.authorizedHumanFinalizerIds.includes(finalization.evaluatorId))
+        return fail('human_finalizer_not_authorized');
+    if (finalization.decision === 'reject') {
+        return nextArtifact(current, transitionFingerprint, 'needs_escalation', current.verdictFingerprints, { reason: 'human_rejection' });
+    }
+    if (!finalization.capability)
+        return fail('capability_required');
+    const capability = verifyApprovalCapability(finalization.capability, context.trustStore, {
+        now: context.now, expectedSubjectArtifactFingerprint: current.artifactFingerprint,
+        binding: current.binding, expectedPurpose: 'hyv.final-approval',
+    });
+    if (!capability.ok)
+        return fail('capability_invalid');
+    return nextArtifact(current, transitionFingerprint, 'approved', current.verdictFingerprints, {
+        capabilityFingerprint: capability.capabilityFingerprint,
+    });
+}
 export function reduceRewriteLifecycle(current, rawAction, context) {
     let action;
     let transitionFingerprint;
@@ -140,49 +206,7 @@ export function reduceRewriteLifecycle(current, rawAction, context) {
         return fail('stale_parent');
     if (current.status === 'approved' || current.status === 'needs_escalation')
         return fail('terminal_state');
-    if (action.type === 'semantic_submission') {
-        if (current.status !== 'needs_semantic_review')
-            return fail('out_of_order_transition');
-        const required = current.semanticPolicy === 'normal' ? 1 : 3;
-        if (action.verdicts.length !== required)
-            return fail('invalid_verdict_count');
-        const ids = action.verdicts.map((verdict) => verdict.evaluatorId);
-        if (new Set(ids).size !== ids.length)
-            return fail('duplicate_evaluator');
-        const authorized = current.semanticPolicy === 'normal' ? context.authorizedSemanticEvaluatorIds.normal : context.authorizedSemanticEvaluatorIds.highAssurance;
-        if (current.semanticPolicy === 'high_assurance' && new Set(authorized).size < 3)
-            return fail('invalid_verdict_count');
-        if (ids.some((id) => !authorized.includes(id)))
-            return fail('evaluator_not_authorized');
-        for (const verdict of action.verdicts) {
-            if (action.taskFingerprint !== current.semanticTaskFingerprint || verdict.taskFingerprint !== action.taskFingerprint)
-                return fail('task_fingerprint_mismatch');
-            if (!same(verdict.binding, current.binding))
-                return fail('invalid_binding');
-            if (verdict.judgmentType !== 'semantic' || hash('hyv:semantic-evidence-scope:v1', verdict.evidenceScope) !== current.semanticEvidenceScopeFingerprint)
-                return fail('evidence_scope_mismatch');
-            if ((verdict.approved && verdict.violations.length) || (!verdict.approved && !verdict.violations.length))
-                return fail('contradictory_verdict');
-        }
-        const verdictFingerprints = action.verdicts.map((verdict) => hash('hyv:semantic-verdict:v1', verdict));
-        const approvals = action.verdicts.filter((verdict) => verdict.approved).length;
-        const status = approvals === required ? 'ready_for_human_review' : 'needs_escalation';
-        const reason = status === 'needs_escalation' ? (approvals === 0 ? 'semantic_rejection' : 'semantic_disagreement') : undefined;
-        return { ok: true, artifact: artifact({ version: '1', status, parentArtifactFingerprint: current.artifactFingerprint, transitionFingerprint, binding: current.binding, semanticPolicy: current.semanticPolicy, semanticTaskFingerprint: current.semanticTaskFingerprint, semanticEvidenceScopeFingerprint: current.semanticEvidenceScopeFingerprint, verdictFingerprints, ...(reason ? { reason } : {}) }) };
-    }
-    if (current.status !== 'ready_for_human_review')
-        return fail('out_of_order_transition');
-    const finalization = action.finalization;
-    if (finalization.parentArtifactFingerprint !== current.artifactFingerprint || !same(finalization.binding, current.binding) || finalization.judgmentType !== 'human_finalization' || finalization.evidenceScope.kind !== 'candidate')
-        return fail('invalid_binding');
-    if (!context.authorizedHumanFinalizerIds.includes(finalization.evaluatorId))
-        return fail('human_finalizer_not_authorized');
-    if (finalization.decision === 'reject')
-        return { ok: true, artifact: artifact({ version: '1', status: 'needs_escalation', parentArtifactFingerprint: current.artifactFingerprint, transitionFingerprint, binding: current.binding, semanticPolicy: current.semanticPolicy, semanticTaskFingerprint: current.semanticTaskFingerprint, semanticEvidenceScopeFingerprint: current.semanticEvidenceScopeFingerprint, verdictFingerprints: current.verdictFingerprints, reason: 'human_rejection' }) };
-    if (!finalization.capability)
-        return fail('capability_required');
-    const capability = verifyApprovalCapability(finalization.capability, context.trustStore, { now: context.now, expectedSubjectArtifactFingerprint: current.artifactFingerprint, binding: current.binding, expectedPurpose: 'hyv.final-approval' });
-    if (!capability.ok)
-        return fail('capability_invalid');
-    return { ok: true, artifact: artifact({ version: '1', status: 'approved', parentArtifactFingerprint: current.artifactFingerprint, transitionFingerprint, binding: current.binding, semanticPolicy: current.semanticPolicy, semanticTaskFingerprint: current.semanticTaskFingerprint, semanticEvidenceScopeFingerprint: current.semanticEvidenceScopeFingerprint, verdictFingerprints: current.verdictFingerprints, capabilityFingerprint: capability.capabilityFingerprint }) };
+    return action.type === 'semantic_submission'
+        ? submitReview(current, action, context, transitionFingerprint)
+        : finalizeReview(current, action, context, transitionFingerprint);
 }

package/dist/stage1-evaluation.js

@@ -449,9 +449,19 @@ function parseReleaseAudit(protocol, input) {
         fail('release_audit_binding_mismatch');
     return audit;
 }
-function correctionCount(ratings, mapping, arm, result) {
-    const label = mapping.labels.A === arm ? 'A' : 'B';
-    return ratings.filter((rating) => rating.correctionVersusConfirm[label] === result).length;
+function rate(numerator, denominator) {
+    return { numerator, denominator, rate: numerator / denominator, uncertainty95: wilson95(numerator, denominator) };
+}
+function corrections(ratings, label, denominator) {
+    let corrections = 0;
+    let confirms = 0;
+    for (const rating of ratings) {
+        if (rating.correctionVersusConfirm[label] === 'correction')
+            corrections += 1;
+        if (rating.correctionVersusConfirm[label] === 'confirm')
+            confirms += 1;
+    }
+    return { corrections, confirms, denominator, correctionRate: corrections / denominator, uncertainty95: wilson95(corrections, denominator) };
 }
 function workflowForArm(runs, arm) {
     const armRuns = runs.filter((run) => run.arm === arm);
@@ -460,21 +470,26 @@ function workflowForArm(runs, arm) {
 function calculateEvaluation(protocol, runs, ratings, mapping, summary) {
     const completedRatings = ratings.filter((rating) => rating.workflow === 'completed');
     const preferenceDenominator = protocol.intentToTreat.expectedReviewers * protocol.cases.length;
-    const preferred = completedRatings.reduce((total, rating) => total + (rating.preferredLabel === 'tie' ? 0.5 : mapping.labels[rating.preferredLabel] === 'stage1' ? 1 : 0), 0);
+    let preferred = 0;
+    for (const rating of completedRatings) {
+        if (rating.preferredLabel === 'tie')
+            preferred += 0.5;
+        else if (mapping.labels[rating.preferredLabel] === 'stage1')
+            preferred += 1;
+    }
     const preferenceRate = preferenceDenominator ? preferred / preferenceDenominator : 0;
-    const stage1Confirm = correctionCount(completedRatings, mapping, 'stage1', 'confirm');
-    const baselineConfirm = correctionCount(completedRatings, mapping, 'baseline', 'confirm');
-    const stage1Correction = correctionCount(completedRatings, mapping, 'stage1', 'correction');
-    const baselineCorrection = correctionCount(completedRatings, mapping, 'baseline', 'correction');
+    const stage1 = corrections(completedRatings, mapping.labels.A === 'stage1' ? 'A' : 'B', preferenceDenominator);
+    const baseline = corrections(completedRatings, mapping.labels.A === 'baseline' ? 'A' : 'B', preferenceDenominator);
     const baselineWorkflow = workflowForArm(runs, 'baseline');
     const stage1Workflow = workflowForArm(runs, 'stage1');
-    const correctionMarginMet = (stage1Confirm - baselineConfirm) / preferenceDenominator >= protocol.analysis.margin;
-    const workflowRegressed = stage1Workflow.denominator === 0 || baselineWorkflow.denominator === 0 || stage1Workflow.completed / stage1Workflow.denominator < baselineWorkflow.completed / baselineWorkflow.denominator;
+    const correctionMarginMet = (stage1.confirms - baseline.confirms) / preferenceDenominator >= protocol.analysis.margin;
+    const workflowRegressed = stage1Workflow.denominator === 0 || baselineWorkflow.denominator === 0
+        || stage1Workflow.completed / stage1Workflow.denominator < baselineWorkflow.completed / baselineWorkflow.denominator;
     const metrics = {
-        preference: { numerator: preferred, denominator: preferenceDenominator, rate: preferenceRate, uncertainty95: wilson95(preferred, preferenceDenominator) },
-        correctionVersusConfirm: { stage1: { corrections: stage1Correction, confirms: stage1Confirm, denominator: preferenceDenominator, correctionRate: stage1Correction / preferenceDenominator, uncertainty95: wilson95(stage1Correction, preferenceDenominator) }, baseline: { corrections: baselineCorrection, confirms: baselineConfirm, denominator: preferenceDenominator, correctionRate: baselineCorrection / preferenceDenominator, uncertainty95: wilson95(baselineCorrection, preferenceDenominator) } },
-        completion: { numerator: completedRatings.length, denominator: preferenceDenominator, rate: completedRatings.length / preferenceDenominator, uncertainty95: wilson95(completedRatings.length, preferenceDenominator) },
-        abandonment: { numerator: ratings.length - completedRatings.length, denominator: preferenceDenominator, rate: (ratings.length - completedRatings.length) / preferenceDenominator, uncertainty95: wilson95(ratings.length - completedRatings.length, preferenceDenominator) },
+        preference: { ...rate(preferred, preferenceDenominator), rate: preferenceRate },
+        correctionVersusConfirm: { stage1, baseline },
+        completion: rate(completedRatings.length, preferenceDenominator),
+        abandonment: rate(ratings.length - completedRatings.length, preferenceDenominator),
         providerRuns: { completed: summary.completed, abandoned: summary.abandonments, hardFailures: summary.hardFailures, timeouts: summary.timeouts, denominator: summary.denominator },
     };
     return { correctionMarginMet, metrics, preferenceDenominator, preferenceRate, workflowRegressed };

package/dist/strict-quality.js

@@ -6,25 +6,17 @@ const MINIMUM_WORDS = 1_500;
 function finding(id, disposition, reason, suggestion, sentence) {
     return { id, disposition, reason, suggestion, ...(sentence === undefined ? {} : { sentence }) };
 }
+const FINGERPRINT_KEYS = new Map([
+    ['dna.fingerprint.contraction-rate', 'contractionRate'],
+    ['dna.fingerprint.sentence-length-distribution', 'sentenceLengthDistribution'],
+    ['dna.fingerprint.bullet-rate', 'bulletRate'],
+    ['dna.fingerprint.en-dash-rate', 'enDashRate'],
+]);
 function strictFinding(source, profile) {
-    if (source.engine === 'ai_editor') {
-        return finding(`strict.${source.engine}.${source.id}`, 'block', source.reason, source.suggestion, source.sentence);
-    }
-    if (source.engine === 'voice_dna') {
-        if (source.severity === 'red')
-            return finding(`strict.${source.engine}.${source.id}`, 'block', source.reason, source.suggestion, source.sentence);
-        if (source.id.startsWith('dna.fingerprint.')) {
-            const metric = source.id.slice('dna.fingerprint.'.length);
-            const key = metric === 'contraction-rate' ? 'contractionRate'
-                : metric === 'sentence-length-distribution' ? 'sentenceLengthDistribution'
-                    : metric === 'bullet-rate' ? 'bulletRate'
-                        : metric === 'en-dash-rate' ? 'enDashRate' : undefined;
-            if (key && profile.tolerances[key].calibrated)
-                return finding(`strict.${source.engine}.${source.id}`, 'block', source.reason, source.suggestion, source.sentence);
-        }
-        return finding(`strict.${source.engine}.${source.id}`, 'review', source.reason, source.suggestion, source.sentence);
-    }
-    return finding(`strict.${source.engine}.${source.id}`, source.severity === 'red' ? 'block' : 'review', source.reason, source.suggestion, source.sentence);
+    const metric = FINGERPRINT_KEYS.get(source.id);
+    const calibratedDrift = source.engine === 'voice_dna' && metric && profile.tolerances[metric].calibrated;
+    const blocks = source.engine === 'ai_editor' || source.severity === 'red' || calibratedDrift;
+    return finding(`strict.${source.engine}.${source.id}`, blocks ? 'block' : 'review', source.reason, source.suggestion, source.sentence);
 }
 export function evaluateStrictQuality(draft, profile, samples, brief) {
     const readiness = assessProfileReadiness(samples);

package/dist/version.js

@@ -1 +1 @@
-export const HYV_VERSION = '3.6.1';
+export const HYV_VERSION = '4.0.0';

package/dist/voice-dna.js

@@ -16,12 +16,18 @@ function top(items, limit) {
         counts.set(item, (counts.get(item) ?? 0) + 1);
     return [...counts].sort((left, right) => right[1] - left[1]).slice(0, limit).map(([item]) => item);
 }
+function measureWriting(text, tokens) {
+    const mapped = sentences(text);
+    return { text, mapped, tokens: tokens ?? words(text), sentenceWords: mapped.map((sentence) => words(sentence.text)) };
+}
 export function profileMetrics(text) {
-    const draftSentences = sentences(text);
-    const draftWords = words(text);
-    const lengths = draftSentences.map((sentence) => words(sentence.text).length);
-    const starters = draftSentences.map((sentence) => words(sentence.text)[0]?.toLowerCase() ?? '');
-    const structures = draftSentences.map((sentence) => words(sentence.text).slice(0, 3).map((word) => word.toLowerCase()).join(' '));
+    return metricsFor(measureWriting(text));
+}
+function metricsFor(writing) {
+    const { text, mapped: draftSentences, tokens: draftWords, sentenceWords } = writing;
+    const lengths = sentenceWords.map((tokens) => tokens.length);
+    const starters = sentenceWords.map((tokens) => tokens[0]?.toLowerCase() ?? '');
+    const structures = sentenceWords.map((tokens) => tokens.slice(0, 3).map((word) => word.toLowerCase()).join(' '));
     const lowerWords = draftWords.map((word) => word.toLowerCase());
     const nonStop = lowerWords.filter((word) => word.length > 3 && !STOP_WORDS.has(word));
     const first = lowerWords.filter((word) => ['i', 'we', 'my', 'our', 'us'].includes(word)).length;
@@ -52,17 +58,18 @@ export function profileMetrics(text) {
     };
 }
 export function measureFounderFingerprint(text) {
-    const draftWords = words(text);
+    return fingerprintFor(measureWriting(text, words(text)));
+}
+function fingerprintFor(writing) {
+    const { text, mapped: draftSentences, tokens: draftWords, sentenceWords } = writing;
     const wordDenominator = Math.max(1, draftWords.length);
     const contractionCount = draftWords.filter((word) => CONTRACTIONS.has(word.toLowerCase().replaceAll('’', "'"))).length;
-    const draftSentences = sentences(text);
     const sentenceDenominator = Math.max(1, draftSentences.length);
     const buckets = { short: 0, medium: 0, long: 0 };
-    for (const sentence of draftSentences) {
-        const length = words(sentence.text).length;
-        if (length <= 8)
+    for (const tokens of sentenceWords) {
+        if (tokens.length <= 8)
             buckets.short += 1;
-        else if (length <= 20)
+        else if (tokens.length <= 20)
             buckets.medium += 1;
         else
             buckets.long += 1;
@@ -81,16 +88,21 @@ export function measureFounderFingerprint(text) {
         enDashRate: (text.match(/–/g) ?? []).length / wordDenominator,
     };
 }
-export function buildProfile(samples, avoid = []) {
+function measureSamples(samples, avoid) {
     if (samples.length < 2)
         throw new Error('Provide at least two local writing samples.');
     if (samples.some((sample) => !words(sample).length))
         throw new Error('Every local writing sample must contain writing.');
-    return { version: '2', sampleCount: samples.length, metrics: profileMetrics(samples.join('\n\n')), avoid };
+    const writing = measureWriting(samples.join('\n\n'));
+    const profile = { version: '2', sampleCount: samples.length, metrics: metricsFor(writing), avoid };
+    return { writing, profile };
+}
+export function buildProfile(samples, avoid = []) {
+    return measureSamples(samples, avoid).profile;
 }
 export function buildProfileV3(samples, id, channel, avoid = [], tone) {
-    const base = buildProfile(samples, avoid);
-    const sampleText = samples.join('\n\n');
+    const { profile: base, writing } = measureSamples(samples, avoid);
+    const ruleAllowances = deriveRuleAllowances(samples);
     const fixtureIds = samples.map((_, index) => 'sample.' + String(index + 1).padStart(3, '0'));
     const unsigned = {
         version: '3',
@@ -101,10 +113,10 @@ export function buildProfileV3(samples, id, channel, avoid = [], tone) {
         avoid: base.avoid,
         provenance: { source: 'local-author-owned-samples', rights: 'author-owned', createdAt: new Date().toISOString() },
         rulePolicy: {},
-        ...(Object.keys(deriveRuleAllowances(samples)).length ? { ruleAllowances: deriveRuleAllowances(samples) } : {}),
+        ...(Object.keys(ruleAllowances).length ? { ruleAllowances } : {}),
         channel,
         ...(tone ? { tone } : {}),
-        fingerprint: measureFounderFingerprint(sampleText),
+        fingerprint: fingerprintFor(writing),
         tolerances: {
             contractionRate: { absolute: 0.1, calibrated: false },
             sentenceLengthDistribution: { absolute: 0.15, calibrated: false },
@@ -121,11 +133,12 @@ function finding(id, severity, sentence, excerpt, reason, suggestion) {
     return { engine: 'voice_dna', id, severity, sentence, excerpt, reason, suggestion };
 }
 export function analyzeVoiceDna(text, profile) {
-    const metrics = profileMetrics(text);
+    const writing = measureWriting(text);
+    const metrics = metricsFor(writing);
     const findings = [];
     const tolerance = Math.max(8, profile.metrics.sentenceVariation * 2.2);
-    for (const sentence of sentences(text)) {
-        const count = words(sentence.text).length;
+    for (const [index, sentence] of writing.mapped.entries()) {
+        const count = writing.sentenceWords[index].length;
         if (Math.abs(count - profile.metrics.sentenceLength) > tolerance)
             findings.push(finding('dna.sentence-length', 'yellow', sentence.index, sentence.text, `Sentence length (${count}) is outside the profile band around ${profile.metrics.sentenceLength}.`, 'Restore the writer’s usual sentence length where it improves clarity.'));
         for (const banned of profile.avoid)
@@ -139,7 +152,7 @@ export function analyzeVoiceDna(text, profile) {
     if (metrics.pointOfView !== profile.metrics.pointOfView && profile.metrics.pointOfView !== 'mixed')
         findings.push(finding('dna.point-of-view', 'yellow', 1, text.slice(0, 160), `Draft point of view is ${metrics.pointOfView}; profile is ${profile.metrics.pointOfView}.`, 'Restore the writer’s normal narrative distance.'));
     if (profile.version === '3') {
-        const measured = measureFounderFingerprint(text);
+        const measured = fingerprintFor(writing);
         const fingerprintChecks = [
             ['contraction-rate', measured.contractionRate, profile.fingerprint.contractionRate, profile.tolerances.contractionRate],
             ['sentence-length-distribution', Math.max(Math.abs(measured.sentenceLengthDistribution.short - profile.fingerprint.sentenceLengthDistribution.short), Math.abs(measured.sentenceLengthDistribution.medium - profile.fingerprint.sentenceLengthDistribution.medium), Math.abs(measured.sentenceLengthDistribution.long - profile.fingerprint.sentenceLengthDistribution.long)), 0, profile.tolerances.sentenceLengthDistribution],

package/dist/writing-examples.js

@@ -31,19 +31,14 @@ function validate(inputs) {
 function indexExamples(inputs) {
     const entries = inputs.flatMap((input) => sentences(input.text).map((sentence, position) => ({ source: input.basename, position, text: sentence.text, terms: tokens(sentence.text) })));
     const postings = new Map();
-    const documentFrequency = new Map();
     for (const [entryIndex, entry] of entries.entries()) {
-        const seen = new Set();
         for (const term of entry.terms) {
             const posting = postings.get(term) ?? new Map();
             posting.set(entryIndex, (posting.get(entryIndex) ?? 0) + 1);
             postings.set(term, posting);
-            seen.add(term);
         }
-        for (const term of seen)
-            documentFrequency.set(term, (documentFrequency.get(term) ?? 0) + 1);
     }
-    return { entries, postings, documentFrequency };
+    return { entries, postings };
 }
 /** Finds redacted local examples in supplied memory only; it never creates a corpus or index on disk. */
 export function findWritingExamples(query, inputs, limit = 3) {
@@ -58,7 +53,7 @@ export function findWritingExamples(query, inputs, limit = 3) {
         const posting = index.postings.get(term);
         if (!posting)
             continue;
-        const idf = Math.log(1 + (index.entries.length - (index.documentFrequency.get(term) ?? 0) + 0.5) / ((index.documentFrequency.get(term) ?? 0) + 0.5));
+        const idf = Math.log(1 + (index.entries.length - posting.size + 0.5) / (posting.size + 0.5));
         for (const [entryIndex, frequency] of posting) {
             const entry = index.entries[entryIndex];
             const denominator = frequency + 1.2 * (1 - 0.75 + 0.75 * entry.terms.length / Math.max(1, averageLength));