@holdyourvoice/hyv 3.6.1 → 4.0.1

package/dist/rewrite-task.js

@@ -1,3 +1,4 @@
+import { deriveFactRepair, isSourceBackedRepair } from './rewrite-prompt.js';
 import { parseWritingBrief } from './editorial-packs.js';
 import { finalOutputCheck, hygieneSourceFindings } from './hygiene.js';
 import { analyze, deriveEditScope, renderRewritePrompt, verifyDeterministically } from './pipeline.js';
@@ -9,47 +10,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,39 +50,62 @@ 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' };
-    }
-    catch {
-        return { 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')
+        return parseRangeResponse(response);
+    if (response.version !== '1')
+        return failure('invalid_response_version', 'Response version must be "1" or "2".', 'version');
+    return parseReplacements(response);
 }
-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 };
+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'] };
+    }
+    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'] };
+        }
+    }
+    return { response, adapterIds: [] };
 }
 export function prepareRewriteTask(draft, profile, copySpec, writingBrief, authorizedSentenceIds = []) {
     const result = analyze(draft, profile, writingBrief);
-    const prompt = renderRewritePrompt(draft, profile, result, [], writingBrief);
+    const factRepair = deriveFactRepair(draft, writingBrief);
+    const prompt = renderRewritePrompt(draft, profile, result, [], writingBrief, [], factRepair, authorizedSentenceIds);
     const mapped = sentences(draft);
-    const eligibleSentenceIds = new Set([...deriveEditScope(result, true).eligibleSentenceIds, ...authorizedSentenceIds]);
+    const eligibleSentenceIds = new Set([...deriveEditScope(result, true).eligibleSentenceIds, ...(factRepair?.eligibleSentenceIds ?? []), ...authorizedSentenceIds]);
     const taskBase = {
         version: '1',
         draft,
         sentences: mapped.map((sentence) => ({ id: sentence.index, text: sentence.text, eligible: eligibleSentenceIds.has(sentence.index) })),
         eligibleSentenceIds: [...eligibleSentenceIds].sort((left, right) => left - right),
         prompt,
+        ...(factRepair ? { factRepair } : {}),
         ...(copySpec ? { copySpec } : {}),
         ...(writingBrief ? { writingBrief } : {}),
     };
@@ -135,12 +144,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 +209,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)}`;
@@ -238,10 +242,53 @@ export function evaluateRewriteResponse(task, raw, profile) {
     const deterministicArtifact = checked.artifact;
     if (!verification.passed) {
         const { candidate: _candidate, ...withheld } = applied;
-        return { ...withheld, status: 'needs_escalation', verification };
+        return { ...withheld, status: 'needs_escalation', verification, feedback: rewriteFeedback(task, candidate, verification, output.changed) };
     }
     const lifecycleBinding = createRewriteLifecycleBinding(task, applied.receipt, deterministicArtifact);
-    return { ...applied, candidate, status: 'needs_semantic_review', verification, deterministicArtifact, lifecycleBinding };
+    const pendingFacts = verification.factLint?.findings.filter((finding) => finding.severity !== 'error') ?? [];
+    const feedback = pendingFacts.length ? {
+        disposition: 'review_required',
+        message: 'Deterministic checks passed, but fact findings remain uncertain. Review the cited evidence during semantic review; these findings grant no added edit permission.',
+        blockers: pendingFacts.map((finding) => ({ gate: 'facts', disposition: 'review_required', sentenceIds: [finding.draftLocation.sentence], reason: finding.reason })),
+    } : undefined;
+    return { ...applied, candidate, status: 'needs_semantic_review', verification, deterministicArtifact, lifecycleBinding, ...(feedback ? { feedback } : {}) };
+}
+function rewriteFeedback(task, candidate, verification, hygieneChanged) {
+    const sourceHygiene = finalOutputCheck(task.draft);
+    const stableSentenceScope = !hygieneChanged && !sourceHygiene.changed && sourceHygiene.accepted;
+    const protectedText = new Set(task.sentences.filter((sentence) => !sentence.eligible).map((sentence) => sentence.text));
+    const candidateSentences = new Map(sentences(candidate).map((sentence) => [sentence.index, sentence.text]));
+    const inScope = (ids) => stableSentenceScope && ids.length > 0 && ids.every((id) => candidateSentences.has(id) && !protectedText.has(candidateSentences.get(id)));
+    const blockers = [];
+    const add = (gate, reason, sentenceIds = [], repairable = false) => {
+        blockers.push({ gate, sentenceIds: [...new Set(sentenceIds)], reason: repairable && !stableSentenceScope ? `${reason} Hygiene normalization prevents reliable original sentence scope matching; review before retrying.` : reason, disposition: repairable && inScope(sentenceIds) ? 'repair_in_scope' : 'review_required' });
+    };
+    if (verification.strictFindings.length) {
+        for (const finding of verification.strictFindings)
+            add('analysis', finding.reason, [finding.sentence], true);
+    }
+    else if (!verification.candidate.passed)
+        add('analysis', 'The aggregate analysis gate failed without a sentence-level repair. Review the profile or task scope.');
+    for (const finding of verification.factLint?.findings ?? []) {
+        if (finding.severity === 'error')
+            add('facts', finding.reason, [finding.draftLocation.sentence], isSourceBackedRepair(finding, task.writingBrief?.factSources));
+    }
+    if (!verification.logicLint.passed)
+        add('logic', 'Resolve the reported logic conflict with a reviewer before changing claims.', verification.logicLint.findings.filter((finding) => finding.severity === 'error').map((finding) => finding.sentence));
+    if (verification.preservationScore < 70)
+        add('preservation', 'The candidate does not preserve enough source content. Review the changes before retrying.');
+    if (verification.requiredFacts && !verification.requiredFacts.passed)
+        add('required_facts', 'Required facts are missing or denied. Review their compatibility with the authorized edits.');
+    if ('claims' in verification && !verification.claims.passed)
+        add('copy_spec', 'CopySpec claim verification failed. Review the immutable claims before retrying.');
+    if (!verification.finalOutput.accepted)
+        add('hygiene', 'Final-output hygiene remains unresolved. Review the reported characters and their permitted removal.');
+    if (!blockers.length)
+        add('analysis', 'Verification failed without a localized repair. Review the verification report.');
+    const disposition = blockers.some((blocker) => blocker.disposition === 'review_required') ? 'review_required' : 'repair_in_scope';
+    return { disposition, message: disposition === 'review_required'
+            ? 'Stop automatic retries. Resolve the listed blockers with a reviewer or obtain a newly authorized task; protected sentences remain locked.'
+            : 'Repair only the listed blockers within this task scope, then verify again. Sentence IDs refer to the evaluated candidate; submit replacements using the original task IDs.', blockers };
 }
 export function createRewriteLifecycleBinding(task, receipt, deterministic) {
     if (!deterministic.passed || receipt.taskFingerprint !== task.fingerprint)

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.1';