@holdyourvoice/hyv 3.6.0 → 4.0.0

package/dist/rewrite-response.js

@@ -0,0 +1,27 @@
+const MAX_RESPONSE_BYTES = 100_000;
+export function failure(code, message, path) {
+    return { code, message, ...(path ? { path } : {}) };
+}
+export function parseResponseJson(value) {
+    if (Buffer.byteLength(value) > MAX_RESPONSE_BYTES)
+        return failure('response_too_large', `Response exceeds ${MAX_RESPONSE_BYTES} bytes.`);
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return failure('invalid_json', 'Response must be valid JSON.');
+    }
+}
+export function projectLifecycleBinding(taskFingerprint, receipt, deterministic) {
+    return {
+        rewriteTaskFingerprint: taskFingerprint,
+        rewriteResponseFingerprint: receipt.responseFingerprint,
+        deterministicArtifactFingerprint: deterministic.artifactFingerprint,
+        sourceHash: deterministic.sourceHash,
+        candidateHash: deterministic.candidateHash,
+        profileId: deterministic.profileId,
+        profileRevisionDigest: deterministic.profileRevisionDigest,
+        rulesetVersion: deterministic.rulesetVersion,
+        schemaVersion: '1',
+    };
+}

package/dist/rewrite-task.js

@@ -3,69 +3,38 @@ import { finalOutputCheck, hygieneSourceFindings } from './hygiene.js';
 import { analyze, deriveEditScope, renderRewritePrompt, verifyDeterministically } from './pipeline.js';
 import { sentences } from './text.js';
 import { fingerprint } from './internal.js';
-const MAX_RESPONSE_BYTES = 100_000;
+import { failure, parseResponseJson, projectLifecycleBinding } from './rewrite-response.js';
 const MAX_REPLACEMENTS = 100;
 const MAX_REPLACEMENT_CHARACTERS = 10_000;
-function failure(code, message, path) {
-    return { code, message, ...(path ? { path } : {}) };
-}
-function responseFingerprint(response) {
-    return fingerprint(response);
-}
-function parseJson(value) {
-    if (Buffer.byteLength(value) > MAX_RESPONSE_BYTES)
-        return failure('response_too_large', `Response exceeds ${MAX_RESPONSE_BYTES} bytes.`);
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return failure('invalid_json', 'Response must be valid JSON.');
-    }
-}
 function isFailure(value) {
     return typeof value === 'object' && value !== null && 'code' in value;
 }
-function parseResponse(value) {
-    const raw = typeof value === 'string' ? parseJson(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)
@@ -80,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' };
-    }
-    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);
@@ -133,7 +123,7 @@ export function parseRewriteTask(value) {
     return task;
 }
 function rejected(task, raw, failures, adapterIds = []) {
-    return { status: 'repairable', failures, receipt: { version: '1', taskFingerprint: task.fingerprint, responseFingerprint: responseFingerprint(raw), adapterIds, replacementSentenceIds: [] } };
+    return { status: 'repairable', failures, receipt: { version: '1', taskFingerprint: task.fingerprint, responseFingerprint: fingerprint(raw), adapterIds, replacementSentenceIds: [] } };
 }
 export function applyShip(task) {
     return {
@@ -151,19 +141,14 @@ export function applyShip(task) {
     };
 }
 export function applyRewriteResponse(task, raw) {
-    const source = typeof raw === 'string' ? parseJson(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)
         return rejected(task, raw, [failure('task_fingerprint_mismatch', 'Response task fingerprint does not match this task.', 'taskFingerprint')], adapterIds);
     if ('mode' in response && response.mode === 'SHIP') {
         const shipped = applyShip(task);
-        return { ...shipped, receipt: { ...shipped.receipt, adapterIds, responseFingerprint: responseFingerprint(raw) } };
+        return { ...shipped, receipt: { ...shipped.receipt, adapterIds, responseFingerprint: fingerprint(raw) } };
     }
     if (response.version === '2')
         return applyRangeResponse(task, response, raw, adapterIds);
@@ -189,7 +174,7 @@ export function applyRewriteResponse(task, raw) {
         if (replacement !== undefined)
             candidate = `${candidate.slice(0, sentence.start)}${replacement}${candidate.slice(sentence.end)}`;
     }
-    return { status: 'accepted', candidate, failures: [], receipt: { version: '1', taskFingerprint: task.fingerprint, responseFingerprint: responseFingerprint(raw), adapterIds, replacementSentenceIds: [...seen].sort((left, right) => left - right), mode: 'EDIT' } };
+    return { status: 'accepted', candidate, failures: [], receipt: { version: '1', taskFingerprint: task.fingerprint, responseFingerprint: fingerprint(raw), adapterIds, replacementSentenceIds: [...seen].sort((left, right) => left - right), mode: 'EDIT' } };
 }
 function applyRangeResponse(task, response, raw, adapterIds) {
     const sentenceMap = new Map(task.sentences.map((sentence) => [sentence.id, sentence]));
@@ -221,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)}`;
@@ -236,7 +221,7 @@ function applyRangeResponse(task, response, raw, adapterIds) {
         receipt: {
             version: '1',
             taskFingerprint: task.fingerprint,
-            responseFingerprint: responseFingerprint(raw),
+            responseFingerprint: fingerprint(raw),
             adapterIds,
             operationRanges: response.operations.map((operation) => ({ startSentenceId: operation.startSentenceId, endSentenceId: operation.endSentenceId })),
             mode: 'EDIT',
@@ -262,15 +247,5 @@ export function evaluateRewriteResponse(task, raw, profile) {
 export function createRewriteLifecycleBinding(task, receipt, deterministic) {
     if (!deterministic.passed || receipt.taskFingerprint !== task.fingerprint)
         throw new Error('Lifecycle binding requires a passed deterministic artifact for this rewrite task.');
-    return {
-        rewriteTaskFingerprint: task.fingerprint,
-        rewriteResponseFingerprint: receipt.responseFingerprint,
-        deterministicArtifactFingerprint: deterministic.artifactFingerprint,
-        sourceHash: deterministic.sourceHash,
-        candidateHash: deterministic.candidateHash,
-        profileId: deterministic.profileId,
-        profileRevisionDigest: deterministic.profileRevisionDigest,
-        rulesetVersion: deterministic.rulesetVersion,
-        schemaVersion: '1',
-    };
+    return projectLifecycleBinding(task.fingerprint, receipt, deterministic);
 }

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.0';
+export const HYV_VERSION = '4.0.0';