@holdyourvoice/hyv 3.6.0 → 4.0.0

package/dist/copy-spec.js

@@ -40,12 +40,12 @@ export function verifyClaims(candidate, spec) {
             const atoms = claim.atoms.map(normalized);
             const presentAtoms = new Set();
             for (const sentence of draftSentences) {
-                if (atoms.some((atom) => atomMatches(sentence.normalizedText, atom))) {
-                    for (const atom of atoms)
-                        if (atomMatches(sentence.normalizedText, atom))
-                            presentAtoms.add(atom);
-                    (sentenceClaims[sentence.index] ??= []).push(claim.id);
-                }
+                const matches = atoms.filter((atom) => atomMatches(sentence.normalizedText, atom));
+                if (!matches.length)
+                    continue;
+                for (const atom of matches)
+                    presentAtoms.add(atom);
+                (sentenceClaims[sentence.index] ??= []).push(claim.id);
             }
             const missingAtoms = atoms.filter((atom) => !presentAtoms.has(atom));
             if (!claim.mutable && missingAtoms.length) {

package/dist/editorial-packs.js

@@ -23,9 +23,8 @@ function isDenied(text) {
 function isFollowUpDenial(text) {
     return /^(?:that|this) (?:statement|claim|fact|assertion|point) (?:is|was) (?:not|false|untrue|incorrect)\b/i.test(text.trim());
 }
-function hasAffirmedSourceText(source, text) {
+function hasAffirmedSourceText(sourceSentences, text) {
     const expected = text.toLowerCase();
-    const sourceSentences = sentences(source);
     return sourceSentences.some((sentence, index) => sentence.text.toLowerCase().includes(expected) && !isDenied(sentence.text) && !isFollowUpDenial(sourceSentences[index + 1]?.text ?? ''));
 }
 function requiredFactsAreSourced(brief) {
@@ -33,7 +32,9 @@ function requiredFactsAreSourced(brief) {
         return true;
     if (!brief.factSources?.length)
         return false;
-    return brief.requiredFacts.every((fact) => brief.factSources?.some((source) => hasAffirmedSourceText(source.text, fact.text) || (fact.atoms?.length && fact.atoms.every((atom) => hasAffirmedSourceText(source.text, atom)))));
+    const sources = brief.factSources.map((source) => sentences(source.text));
+    return brief.requiredFacts.every((fact) => sources.some((source) => hasAffirmedSourceText(source, fact.text)
+        || (fact.atoms?.length && fact.atoms.every((atom) => hasAffirmedSourceText(source, atom)))));
 }
 function isArgumentMap(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))

package/dist/fact-linter.js

@@ -5,11 +5,13 @@ const QUOTE = /["“]([^"”]+)["”]/;
 function normal(value) { return value.toLowerCase().replace(/[^\p{L}\p{N}%]+/gu, ' ').trim(); }
 function tokens(value) { return normal(value).split(' ').filter((word) => word.length > 1 && !STOP_WORDS.has(word)); }
 function evidence(source, text) { const start = source.text.indexOf(text); return { sourceId: source.id, excerpt: text, start: Math.max(0, start), end: Math.max(0, start) + text.length }; }
-function sourceSentences(sources) { return sources.flatMap((source) => sentences(source.text).map((sentence) => ({ source, text: sentence.text }))); }
-function hasOverlap(claim, source) {
-    const claimTokens = tokens(claim);
-    const sourceTokens = new Set(tokens(source));
-    return claimTokens.length > 0 && claimTokens.filter((token) => sourceTokens.has(token)).length / claimTokens.length >= 0.8;
+function sourceSentences(sources) {
+    return sources.flatMap((source) => sentences(source.text).map((sentence) => ({
+        source, text: sentence.text, terms: new Set(tokens(sentence.text)),
+    })));
+}
+function hasOverlap(claimTerms, source) {
+    return claimTerms.length > 0 && claimTerms.filter((term) => source.terms.has(term)).length / claimTerms.length >= 0.8;
 }
 function dates(value) { return [...value.matchAll(DATE)].map((match) => new Date(match[0]).toISOString().slice(0, 10)).filter((value) => value !== ''); }
 function numbers(value) { return value.match(/\b\d+(?:\.\d+)?\s*(?:%|days?|hours?|weeks?|months?|years?)?\b/gi) ?? []; }
@@ -46,13 +48,11 @@ function kindFor(text) {
         kinds.push('fact');
     return kinds;
 }
-function findRelevant(claim, sources) {
-    const terms = tokens(claim);
-    return sources.filter(({ text }) => terms.some((term) => tokens(text).includes(term)));
+function evidenceFor(lines) {
+    return lines.map(({ source, text }) => evidence(source, text));
 }
 function fallbackEvidence(sources) {
-    const line = sources[0];
-    return line ? [evidence(line.source, line.text)] : [];
+    return evidenceFor(sources.slice(0, 1));
 }
 function finding(claim, kind, severity, reason, evidenceItems, confidence, suggestedAction) {
     return { severity, kind, claim: claim.text, draftLocation: { sentence: claim.sentence, start: claim.start, end: claim.end }, reason, evidence: evidenceItems, confidence, suggestedAction };
@@ -91,14 +91,15 @@ function capabilityFinding(claim, relevant, evidenceItems) {
     return finding(claim, 'missing_evidence', 'needs_human_review', 'The product capability is not established by the relevant source wording.', evidenceItems, 'medium', 'Confirm the capability with a reviewer or add evidence.');
 }
 function findingsForClaim(claim, input, sourceLines, semanticAdapter) {
-    const relevant = findRelevant(claim.text, sourceLines);
-    const same = sourceLines.find(({ text }) => hasOverlap(claim.text, text));
-    const evidenceItems = relevant.length ? relevant.slice(0, 2).map(({ source, text }) => evidence(source, text)) : fallbackEvidence(sourceLines);
+    const claimTerms = tokens(claim.text);
+    const relevant = sourceLines.filter((source) => claimTerms.some((term) => source.terms.has(term)));
+    const same = sourceLines.find((source) => hasOverlap(claimTerms, source));
+    const evidenceItems = relevant.length ? evidenceFor(relevant.slice(0, 2)) : fallbackEvidence(sourceLines);
     const quote = claim.text.match(QUOTE)?.[1];
     const sourceHasAttribution = input.sources.some((source) => /\b(said|according to|reported)\b/i.test(source.text));
     if (quote && sourceHasAttribution && !input.sources.some((source) => source.text.includes(quote))) {
         const quoteRelevant = sourceLines.filter(({ text }) => /\b(said|according to|reported)\b/i.test(text));
-        const quoteEvidence = quoteRelevant.length ? quoteRelevant.slice(0, 2).map(({ source, text }) => evidence(source, text)) : input.sources.slice(0, 1).map((source) => evidence(source, source.text));
+        const quoteEvidence = quoteRelevant.length ? evidenceFor(quoteRelevant.slice(0, 2)) : input.sources.slice(0, 1).map((source) => evidence(source, source.text));
         return [finding(claim, 'quote_drift', 'error', 'The quoted wording differs from the supplied source.', quoteEvidence, 'high', 'Use the source wording or label the text as a paraphrase.')];
     }
     const claimDates = dates(claim.text);
@@ -132,7 +133,7 @@ function findingsForClaim(claim, input, sourceLines, semanticAdapter) {
         return overreach;
     if (claimDates.some((date) => sourceDates.includes(date)) || same)
         return [];
-    if (!relevant.length && claim.kinds.includes('fact') && tokens(claim.text).length <= 4) {
+    if (!relevant.length && claim.kinds.includes('fact') && claimTerms.length <= 4) {
         return [finding(claim, 'missing_evidence', 'needs_human_review', 'No close source evidence was found; the wording is too sparse for a reliable deterministic verdict.', evidenceItems, 'low', 'Confirm with a reviewer or provide a source.')];
     }
     if (!relevant.length || (claim.kinds.includes('number') && !relevant.some(({ text }) => /\b\d+(?:\.\d+)?%?\b/.test(text)))) {
@@ -147,29 +148,46 @@ function findingsForClaim(claim, input, sourceLines, semanticAdapter) {
     return [finding(claim, 'missing_evidence', 'needs_human_review', 'Relevant source material exists, but deterministic matching could not establish support.', evidenceItems, 'low', 'Review the source context or enable an approved semantic adapter.')];
 }
 function draftContradictions(claims, sourceLines) {
-    const normalized = claims.map((claim) => ({ claim, text: normal(claim.text) }));
+    const normalized = claims.map((claim) => {
+        const text = normal(claim.text);
+        return { claim, core: normal(text.replace(/\bnot\b/g, '')), negated: /\bnot\b/.test(text) };
+    });
+    const byCore = new Map();
+    normalized.forEach(({ core }, index) => {
+        const indexes = byCore.get(core) ?? [];
+        indexes.push(index);
+        byCore.set(core, indexes);
+    });
     const findings = [];
     for (let index = 0; index < normalized.length; index += 1) {
-        for (let other = index + 1; other < normalized.length; other += 1) {
-            const left = normalized[index];
+        const left = normalized[index];
+        for (const other of byCore.get(left.core)) {
             const right = normalized[other];
-            const leftCore = normal(left.text.replace(/\bnot\b/g, ''));
-            const rightCore = normal(right.text.replace(/\bnot\b/g, ''));
-            if (leftCore === rightCore && /\bnot\b/.test(left.text) !== /\bnot\b/.test(right.text)) {
+            if (other > index && left.negated !== right.negated) {
                 findings.push(finding(right.claim, 'draft_contradiction', 'error', 'This draft claim contradicts an earlier draft claim.', fallbackEvidence(sourceLines), 'high', 'Resolve the two claims before publishing.'));
             }
         }
     }
     return findings;
 }
+const CONTRADICTIONS = new Set(['draft_contradiction', 'number_drift', 'date_drift', 'entity_drift', 'quote_drift', 'capability_drift', 'semantic_contradiction']);
 function summarizeFindings(claims, findings) {
-    const claimKey = (item) => `${item.draftLocation.start}:${item.draftLocation.end}`;
-    const unsupported = new Set(findings.filter((item) => item.kind === 'unsupported_claim').map(claimKey)).size;
-    const contradicted = new Set(findings.filter((item) => ['draft_contradiction', 'number_drift', 'date_drift', 'entity_drift', 'quote_drift', 'capability_drift', 'semantic_contradiction'].includes(item.kind)).map(claimKey)).size;
-    const humanReview = new Set(findings.filter((item) => item.severity === 'needs_human_review' || item.severity === 'warning').map(claimKey)).size;
+    const unsupported = new Set();
+    const contradicted = new Set();
+    const humanReview = new Set();
+    const affected = new Set();
+    for (const item of findings) {
+        const key = `${item.draftLocation.start}:${item.draftLocation.end}`;
+        affected.add(key);
+        if (item.kind === 'unsupported_claim')
+            unsupported.add(key);
+        if (CONTRADICTIONS.has(item.kind))
+            contradicted.add(key);
+        if (item.severity === 'needs_human_review' || item.severity === 'warning')
+            humanReview.add(key);
+    }
     const checked = claims.filter((claim) => !claim.kinds.includes('opinion')).length;
-    const affected = new Set(findings.map(claimKey)).size;
-    return { checked, supported: Math.max(0, checked - affected), unsupported, contradicted, humanReview };
+    return { checked, supported: Math.max(0, checked - affected.size), unsupported: unsupported.size, contradicted: contradicted.size, humanReview: humanReview.size };
 }
 export function lintFacts(input) {
     if (!input.sources.length)

package/dist/hidden-text.js

@@ -48,13 +48,13 @@ export function inspectHiddenText(text, policy = minimalHiddenTextPolicy) {
 }
 export function applyHiddenTextPolicy(text, policy = minimalHiddenTextPolicy) {
     const report = inspectHiddenText(text, policy);
-    const output = applyOnce(text, policy);
-    const remaining = inspectHiddenText(output, policy).findings;
-    const again = applyOnce(output, policy);
-    return { ...report, outputHash: hash(output), output, remaining, idempotent: again === output };
+    const output = removeProposedChanges(text, report.proposedChanges);
+    const remainingReport = inspectHiddenText(output, policy);
+    const again = removeProposedChanges(output, remainingReport.proposedChanges);
+    return { ...report, outputHash: hash(output), output, remaining: remainingReport.findings, idempotent: again === output };
 }
-function applyOnce(text, policy) {
-    const offsets = new Set(inspectHiddenText(text, policy).proposedChanges.map((item) => item.offset));
+function removeProposedChanges(text, changes) {
+    const offsets = new Set(changes.map((item) => item.offset));
     let output = '';
     for (let offset = 0; offset < text.length;) {
         const value = text.codePointAt(offset);

package/dist/internal.js

@@ -28,3 +28,11 @@ export function isText(value, maximum = 256) {
 export function escaped(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+export function verificationMatchesBinding(verification, binding) {
+    return verification.artifactFingerprint === binding.deterministicArtifactFingerprint
+        && verification.sourceHash === binding.sourceHash
+        && verification.candidateHash === binding.candidateHash
+        && verification.profileId === binding.profileId
+        && verification.profileRevisionDigest === binding.profileRevisionDigest
+        && verification.rulesetVersion === binding.rulesetVersion;
+}

package/dist/judgment-task.js

@@ -17,9 +17,6 @@ function isRange(value) {
         && value.startSentenceId >= 1
         && value.endSentenceId >= value.startSentenceId;
 }
-function rangesContiguous(ranges) {
-    return ranges.every((range) => range.endSentenceId >= range.startSentenceId);
-}
 export function parseJudgmentEnvelope(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new Error('Judgment envelope must be an object.');
@@ -105,12 +102,15 @@ export function fingerprintPreEditReduction(reduction) {
 function reduced(decision, editScope, reason) {
     return { decision, editScope, ...(reason ? { reason } : {}), recommendationFingerprint: fingerprintReduction(decision, editScope, reason) };
 }
-export function reducePreEdit(envelopes) {
-    if (envelopes.length !== PRE_EDIT_KINDS.length)
-        throw new Error('Pre-edit reduction requires triage, argument, and form envelopes.');
+function requireKinds(envelopes, required, message) {
+    if (envelopes.length !== required.length)
+        throw new Error(message);
     const kinds = new Set(envelopes.map((envelope) => envelope.judgmentType));
-    if (PRE_EDIT_KINDS.some((kind) => !kinds.has(kind)))
-        throw new Error('Pre-edit reduction requires triage, argument, and form envelopes.');
+    if (required.some((kind) => !kinds.has(kind)))
+        throw new Error(message);
+}
+export function reducePreEdit(envelopes) {
+    requireKinds(envelopes, PRE_EDIT_KINDS, 'Pre-edit reduction requires triage, argument, and form envelopes.');
     if (envelopes.some((envelope) => envelope.stage !== 'pre-edit'))
         throw new Error('Pre-edit reduction rejects post-candidate envelopes.');
     const argument = envelopes.find((envelope) => envelope.judgmentType === 'argument');
@@ -121,7 +121,7 @@ export function reducePreEdit(envelopes) {
         return reduced('REBUILD', { ranges: [] });
     }
     const ranges = envelopes.flatMap((envelope) => envelope.editScope?.ranges ?? namedRanges(envelope.findings));
-    if (!rangesContiguous(ranges) || ranges.some((range) => range.endSentenceId < range.startSentenceId)) {
+    if (!ranges.every((range) => range.endSentenceId >= range.startSentenceId)) {
         throw new Error('Edit scope must name contiguous sentence ranges.');
     }
     if (envelopes.every((envelope) => envelope.decision === 'SHIP') && ranges.length === 0) {
@@ -132,11 +132,7 @@ export function reducePreEdit(envelopes) {
     return reduced('EDIT', { ranges });
 }
 export function reducePostCandidate(envelopes) {
-    if (envelopes.length !== POST_CANDIDATE_KINDS.length)
-        throw new Error('Post-candidate reduction requires argument, polarity, form, flatness, and semantic envelopes.');
-    const kinds = new Set(envelopes.map((envelope) => envelope.judgmentType));
-    if (POST_CANDIDATE_KINDS.some((kind) => !kinds.has(kind)))
-        throw new Error('Post-candidate reduction requires argument, polarity, form, flatness, and semantic envelopes.');
+    requireKinds(envelopes, POST_CANDIDATE_KINDS, 'Post-candidate reduction requires argument, polarity, form, flatness, and semantic envelopes.');
     if (envelopes.some((envelope) => envelope.stage !== 'post-candidate'))
         throw new Error('Post-candidate reduction rejects pre-edit envelopes.');
     if (envelopes.some((envelope) => envelope.decision === 'REBUILD'))

package/dist/learning.js

@@ -18,7 +18,7 @@ function canonicalJson(value) {
     return JSON.stringify(value);
 }
 export function profileFingerprint(profile) {
-    return createHash('sha256').update(canonicalJson(profile)).digest('hex');
+    return digest(profile);
 }
 function identity(profile) { return profile.version === '3' ? profile.id : profileFingerprint(profile); }
 function revision(profile) { return profile.version === '3' ? profile.revision : 1; }
@@ -99,15 +99,27 @@ function readEventsFromFile(file) {
 function readEvents(profile, options = {}) { return readEventsFromFile(eventFile(profile, options)); }
 function serialize(events) { return events.length ? `${events.map((event) => JSON.stringify(event)).join('\n')}\n` : ''; }
 function learningState(events, profile) {
-    return {
-        superseded: new Set(events.filter((event) => event.kind === 'supersession').map((event) => event.targetEventId)),
-        ratified: new Set(events.filter((event) => event.kind === 'ratification' && event.profileRevision <= revision(profile)).map((event) => event.targetEventId)),
+    const superseded = new Set();
+    const ratified = new Set();
+    const currentRevision = revision(profile);
+    for (const event of events) {
+        if (event.kind === 'supersession')
+            superseded.add(event.targetEventId);
+        if (event.kind === 'ratification' && event.profileRevision <= currentRevision)
+            ratified.add(event.targetEventId);
+    }
+    return (event) => {
+        if (event.kind === 'ratification' || event.kind === 'supersession' || event.kind === 'migration')
+            return 'control';
+        if (superseded.has(event.eventId))
+            return 'superseded';
+        if (ratified.has(event.eventId))
+            return 'active';
+        const compatible = event.profileRevision <= currentRevision
+            && (event.compatibility === 'same-or-newer' || event.profileRevision === currentRevision);
+        return compatible ? 'active' : 'incompatible';
     };
 }
-function isCompatible(event, profile) {
-    return event.profileRevision <= revision(profile)
-        && (event.compatibility === 'same-or-newer' || event.profileRevision === revision(profile));
-}
 function withLock(file, operation) {
     const lock = `${file}.lock`;
     for (let attempt = 0; attempt < 100; attempt += 1) {
@@ -143,7 +155,7 @@ function compact(events) {
     const selected = new Set(content.slice(0, MAX_EVENTS).map((event) => event.eventId));
     const controls = events.filter((event) => event.kind === 'migration' || ((event.kind === 'ratification' || event.kind === 'supersession') && selected.has(event.targetEventId ?? '')));
     while (selected.size + controls.length > MAX_EVENTS)
-        selected.delete(content[[...selected].length - 1]?.eventId ?? '');
+        selected.delete(content[selected.size - 1]?.eventId ?? '');
     const retained = events.filter((event) => selected.has(event.eventId) || (event.kind === 'migration') || ((event.kind === 'ratification' || event.kind === 'supersession') && selected.has(event.targetEventId ?? '')))
         .sort((a, b) => a.timestamp.localeCompare(b.timestamp) || a.eventId.localeCompare(b.eventId));
     while (retained.length && Buffer.byteLength(serialize(retained)) > MAX_STORAGE_BYTES) {
@@ -170,37 +182,46 @@ function receipt(profile, event, status) {
     const publicMetadata = { mutationId: event.mutationId, eventId: event.eventId, profileId: identity(profile), profileRevision: revision(profile), status, timestamp: event.timestamp };
     return { version: '1', ...publicMetadata, digest: digest(publicMetadata) };
 }
-function eventBase(profile, kind, options) {
+function requestDigest(event) {
+    return digest({ ...event, eventId: undefined, timestamp: undefined, requestDigest: undefined });
+}
+function eventBase(profile, kind, options, details = {}) {
     const mutationId = options.mutationId ?? randomUUID();
     const base = {
         version: '2', eventId: digest({ profile: identity(profile), mutationId }), mutationId, timestamp: new Date().toISOString(),
         profileRevision: revision(profile), revisionDigest: revisionDigest(profile), authority: options.authority ?? 'team',
         provenance: options.provenance ?? 'local', weight: options.weight ?? 1, compatibility: options.compatibility ?? 'same-or-newer', kind,
     };
-    return { ...base, requestDigest: digest({ ...base, eventId: undefined, timestamp: undefined, requestDigest: undefined }) };
+    const event = { ...base, requestDigest: '', ...details };
+    event.requestDigest = requestDigest(event);
+    return event;
 }
-function mutate(profile, event, options, validate) {
+function withMutation(profile, event, options, operation, source) {
     try {
-        const directory = learningDirectory(options);
-        mkdirSync(directory, { recursive: true, mode: 0o700 });
+        mkdirSync(learningDirectory(options), { recursive: true, mode: 0o700 });
         const file = eventFile(profile, options);
-        const result = withLock(file, () => {
-            const events = readEventsFromFile(file);
-            const existing = events.find((item) => item.mutationId === event.mutationId);
-            if (existing)
-                return receipt(profile, existing, existing.requestDigest === event.requestDigest ? 'already_recorded' : 'conflict');
-            const invalid = validate?.(events);
-            if (invalid)
-                return receipt(profile, event, invalid);
-            writeEventsAtomically(file, [...events, event]);
-            return receipt(profile, event, 'recorded');
-        });
+        const sourceFile = source ? eventFile(source, options) : undefined;
+        const run = () => operation(file, sourceFile);
+        const result = sourceFile === undefined ? withLock(file, run) : withLocks([sourceFile, file], run);
         return result ?? receipt(profile, event, 'lock_timeout');
     }
     catch (error) {
         return receipt(profile, event, error.message.includes('corrupt') ? 'corrupt' : 'write_failed');
     }
 }
+function mutate(profile, event, options, validate) {
+    return withMutation(profile, event, options, (file) => {
+        const events = readEventsFromFile(file);
+        const existing = events.find((item) => item.mutationId === event.mutationId);
+        if (existing)
+            return receipt(profile, existing, existing.requestDigest === event.requestDigest ? 'already_recorded' : 'conflict');
+        const invalid = validate?.(events);
+        if (invalid)
+            return receipt(profile, event, invalid);
+        writeEventsAtomically(file, [...events, event]);
+        return receipt(profile, event, 'recorded');
+    });
+}
 function countFindings(findings) {
     const counted = new Map();
     for (const finding of findings) {
@@ -224,8 +245,7 @@ export function recordVerifiedCandidate(profile, verification, candidate, option
     const outcome = createHash('sha256').update(`${identity(profile)}\0${candidate}`).digest('hex');
     if (readEvents(profile, options).some((event) => event.kind === 'verified_candidate' && event.outcome === outcome))
         return 'nothing_to_learn';
-    const event = { ...eventBase(profile, 'verified_candidate', { ...options, mutationId: options.mutationId ?? outcome }), resolved: resolved.slice(0, MAX_RESOLVED_FINDINGS), outcome };
-    event.requestDigest = digest({ ...event, eventId: undefined, timestamp: undefined, requestDigest: undefined });
+    const event = eventBase(profile, 'verified_candidate', { ...options, mutationId: options.mutationId ?? outcome }, { resolved: resolved.slice(0, MAX_RESOLVED_FINDINGS), outcome });
     const result = mutate(profile, event, options);
     return result.status === 'recorded' ? 'recorded' : result.status === 'already_recorded' ? 'nothing_to_learn' : 'write_failed';
 }
@@ -235,76 +255,62 @@ export function recordLearningInstruction(profile, instruction, options = {}) {
         throw new Error('Learning instructions cannot be empty.');
     if (normalized.length > MAX_INSTRUCTION_CHARACTERS)
         throw new Error(`Learning instructions must be ${MAX_INSTRUCTION_CHARACTERS} characters or fewer.`);
-    const event = { ...eventBase(profile, 'instruction', options), instruction: normalized };
-    event.requestDigest = digest({ ...event, eventId: undefined, timestamp: undefined, requestDigest: undefined });
+    const event = eventBase(profile, 'instruction', options, { instruction: normalized });
     return mutate(profile, event, options);
 }
 export function addLearningInstruction(profile, instruction, options = {}) { return recordLearningInstruction(profile, instruction, options).status === 'recorded'; }
+function recordControlEvent(profile, kind, targetEventId, options) {
+    const event = eventBase(profile, kind, options, { targetEventId });
+    return mutate(profile, event, options, (events) => {
+        const target = events.find((item) => item.eventId === targetEventId);
+        return !target ? 'not_found' : authorityRank[event.authority] < authorityRank[target.authority] ? 'unauthorized' : undefined;
+    });
+}
 export function ratifyLearningEvent(profile, targetEventId, options = {}) {
-    const event = { ...eventBase(profile, 'ratification', options), targetEventId };
-    event.requestDigest = digest({ ...event, eventId: undefined, timestamp: undefined, requestDigest: undefined });
-    return mutate(profile, event, options, (events) => { const target = events.find((item) => item.eventId === targetEventId); return !target ? 'not_found' : authorityRank[event.authority] < authorityRank[target.authority] ? 'unauthorized' : undefined; });
+    return recordControlEvent(profile, 'ratification', targetEventId, options);
 }
 export function supersedeLearningEvent(profile, targetEventId, options = {}) {
-    const event = { ...eventBase(profile, 'supersession', options), targetEventId };
-    event.requestDigest = digest({ ...event, eventId: undefined, timestamp: undefined, requestDigest: undefined });
-    return mutate(profile, event, options, (events) => { const target = events.find((item) => item.eventId === targetEventId); return !target ? 'not_found' : authorityRank[event.authority] < authorityRank[target.authority] ? 'unauthorized' : undefined; });
+    return recordControlEvent(profile, 'supersession', targetEventId, options);
 }
 export function migrateLearningV2ToV3(source, target, options = {}) {
     const sourceFingerprint = profileFingerprint(source);
     const migrationId = options.mutationId ?? `migration:${digest({ source: sourceFingerprint, target: target.id, revision: target.revision })}`;
     const migrationOptions = { ...options, mutationId: migrationId };
     const marker = { ...eventBase(target, 'migration', migrationOptions), sourceProfile: sourceFingerprint };
-    try {
-        const directory = learningDirectory(options);
-        mkdirSync(directory, { recursive: true, mode: 0o700 });
-        const file = eventFile(target, options);
-        const sourceFile = eventFile(source, options);
-        const result = withLocks([sourceFile, file], () => {
-            const targetEvents = readEventsFromFile(file);
-            const existing = targetEvents.find((event) => event.mutationId === marker.mutationId);
-            if (existing)
-                return receipt(target, existing, 'already_recorded');
-            const migrated = readEventsFromFile(sourceFile).filter((event) => event.kind === 'instruction' || event.kind === 'verified_candidate').map((event) => ({
-                ...event, eventId: digest({ target: target.id, source: event.eventId }), mutationId: `migration:${marker.mutationId}:${event.mutationId}`,
-                profileRevision: target.revision, revisionDigest: target.revisionDigest, provenance: `migration:${sourceFingerprint}`,
-            }));
-            const intended = [...targetEvents, ...migrated, marker];
-            const compacted = compact(intended);
-            if (migrated.some((event) => !compacted.some((item) => item.eventId === event.eventId)) || !compacted.some((item) => item.eventId === marker.eventId))
-                return receipt(target, marker, 'capacity_exceeded');
-            writeEventsAtomically(file, intended);
-            return receipt(target, marker, 'recorded');
-        });
-        return result ?? receipt(target, marker, 'lock_timeout');
-    }
-    catch (error) {
-        return receipt(target, marker, error.message.includes('corrupt') ? 'corrupt' : 'write_failed');
-    }
+    return withMutation(target, marker, options, (file, sourceFile) => {
+        const targetEvents = readEventsFromFile(file);
+        const existing = targetEvents.find((event) => event.mutationId === marker.mutationId);
+        if (existing)
+            return receipt(target, existing, 'already_recorded');
+        const migrated = readEventsFromFile(sourceFile).filter((event) => event.kind === 'instruction' || event.kind === 'verified_candidate').map((event) => ({
+            ...event, eventId: digest({ target: target.id, source: event.eventId }), mutationId: `migration:${marker.mutationId}:${event.mutationId}`,
+            profileRevision: target.revision, revisionDigest: target.revisionDigest, provenance: `migration:${sourceFingerprint}`,
+        }));
+        const intended = [...targetEvents, ...migrated, marker];
+        const retainedIds = new Set(compact(intended).map((event) => event.eventId));
+        if (!retainedIds.has(marker.eventId) || migrated.some((event) => !retainedIds.has(event.eventId)))
+            return receipt(target, marker, 'capacity_exceeded');
+        writeEventsAtomically(file, intended);
+        return receipt(target, marker, 'recorded');
+    }, source);
 }
 export function inspectLearning(profile, options = {}) {
     const events = readEvents(profile, options);
-    const { superseded, ratified } = learningState(events, profile);
+    const statusOf = learningState(events, profile);
     return events.slice(-MAX_EVENTS).map((event) => {
-        const control = event.kind === 'ratification' || event.kind === 'supersession' || event.kind === 'migration';
-        const status = control ? 'control' : superseded.has(event.eventId) ? 'superseded' : isCompatible(event, profile) || ratified.has(event.eventId) ? 'active' : 'incompatible';
         return {
             version: '1', eventId: event.eventId, mutationId: event.mutationId, eventType: event.kind, timestamp: event.timestamp,
             profileRevision: event.profileRevision, authority: event.authority, weight: event.weight,
-            compatibility: event.compatibility, status, ...(event.targetEventId ? { targetEventId: event.targetEventId } : {}),
+            compatibility: event.compatibility, status: statusOf(event), ...(event.targetEventId ? { targetEventId: event.targetEventId } : {}),
         };
     });
 }
 export function composeLearning(profile, options = {}) {
     const events = readEvents(profile, options);
-    const { superseded, ratified } = learningState(events, profile);
+    const statusOf = learningState(events, profile);
     const preferences = new Map();
     for (const event of events) {
-        if (event.kind !== 'instruction' && event.kind !== 'verified_candidate')
-            continue;
-        if (superseded.has(event.eventId))
-            continue;
-        if (!isCompatible(event, profile) && !ratified.has(event.eventId))
+        if (statusOf(event) !== 'active')
             continue;
         const texts = event.kind === 'instruction' && event.instruction ? [{ text: event.instruction, count: event.weight }]
             : (event.resolved ?? []).map((finding) => ({ text: `Previously verified repair: ${finding.engine}/${finding.id}.`, count: finding.count * event.weight }));

package/dist/lifecycle-adapter.js

@@ -3,7 +3,7 @@ import { verifyApprovalCapability } from './approval-capability.js';
 import { createInitialLifecycleArtifact, isValidLifecycleArtifact, parseSemanticVerdict, prepareSemanticReviewTask, reduceRewriteLifecycle } from './semantic-review.js';
 import { verifyDeterministically } from './pipeline.js';
 import { recordVerifiedCandidate } from './learning.js';
-import { MAX_JSON_BYTES } from './internal.js';
+import { MAX_JSON_BYTES, verificationMatchesBinding } from './internal.js';
 export function prepareLifecycle(deterministic, binding, receipt, policy, allowedViolations) {
     const task = prepareSemanticReviewTask(binding, policy, receipt, allowedViolations);
     return { task, artifact: createInitialLifecycleArtifact(task, deterministic) };
@@ -67,10 +67,7 @@ export function recordApprovedLearning(request) {
     if (!replay.ok || canonicalJson(replay.artifact) !== canonicalJson(approved) || approved.status !== 'approved')
         throw new Error('Approved learning is not authorized.');
     const deterministic = verifyDeterministically(source, candidate, profile, copySpec, writingBrief);
-    if (!deterministic.verification.passed || deterministic.artifact.artifactFingerprint !== approved.binding.deterministicArtifactFingerprint
-        || deterministic.artifact.sourceHash !== approved.binding.sourceHash || deterministic.artifact.candidateHash !== approved.binding.candidateHash
-        || deterministic.artifact.profileId !== approved.binding.profileId || deterministic.artifact.profileRevisionDigest !== approved.binding.profileRevisionDigest
-        || deterministic.artifact.rulesetVersion !== approved.binding.rulesetVersion)
+    if (!deterministic.verification.passed || !verificationMatchesBinding(deterministic.artifact, approved.binding))
         throw new Error('Approved learning binding does not match deterministic verification.');
     return recordVerifiedCandidate(profile, deterministic.verification, candidate, { mutationId: `approved:${approved.artifactFingerprint}`, authority: 'team', provenance: `approved:${approved.capabilityFingerprint}`, compatibility: 'exact' });
 }

package/dist/local-eval.js

@@ -23,42 +23,27 @@ function groupedParagraphs(values, label) {
     if (values.length < 2 || values.some((value) => !value.paragraphId || !value.text.trim()) || new Set(values.map((value) => value.paragraphId)).size < 2)
         throw new Error(`${label} needs at least two paragraph IDs with text.`);
 }
-function tfIdf(documents) {
-    const documentTerms = documents.map((document) => terms(document));
-    const df = new Map();
-    for (const document of documentTerms)
-        for (const term of new Set(document))
-            df.set(term, (df.get(term) ?? 0) + 1);
-    const vocabulary = [...df.keys()].sort();
-    const idf = new Map([...df].map(([term, frequency]) => [term, Math.log((documents.length + 1) / (frequency + 1)) + 1]));
-    const toVector = (document) => {
-        const termsInDocument = terms(document);
-        const count = new Map();
-        for (const term of termsInDocument)
-            count.set(term, (count.get(term) ?? 0) + 1);
-        const vector = {};
-        for (const [term, occurrences] of count)
-            if (idf.has(term))
-                vector[term] = (occurrences / Math.max(1, termsInDocument.length)) * idf.get(term);
-        return vector;
-    };
-    return {
-        vocabulary,
-        idf,
-        vectors: documents.map(toVector),
-    };
-}
-function vectorWithIdf(document, idf) {
-    const documentTerms = terms(document);
-    const count = new Map();
+function vectorWithIdf(documentTerms, idf) {
+    const counts = new Map();
     for (const term of documentTerms)
-        count.set(term, (count.get(term) ?? 0) + 1);
+        counts.set(term, (counts.get(term) ?? 0) + 1);
     const vector = {};
-    for (const [term, occurrences] of count)
+    for (const [term, occurrences] of counts) {
         if (idf.has(term))
             vector[term] = (occurrences / Math.max(1, documentTerms.length)) * idf.get(term);
+    }
     return vector;
 }
+function tfIdf(documents) {
+    const documentTerms = documents.map(terms);
+    const frequencies = new Map();
+    for (const document of documentTerms) {
+        for (const term of new Set(document))
+            frequencies.set(term, (frequencies.get(term) ?? 0) + 1);
+    }
+    const idf = new Map([...frequencies].map(([term, frequency]) => [term, Math.log((documents.length + 1) / (frequency + 1)) + 1]));
+    return { idf, vectors: documentTerms.map((document) => vectorWithIdf(document, idf)) };
+}
 function sigmoid(value) { return value >= 0 ? 1 / (1 + Math.exp(-value)) : Math.exp(value) / (1 + Math.exp(value)); }
 /** Deterministic, train-only logistic regression over sparse TF-IDF vectors. */
 function localAuthorshipProbability(candidate, user, shadow) {
@@ -75,7 +60,7 @@ function localAuthorshipProbability(candidate, user, shadow) {
                 weights[term] = (weights[term] ?? 0) + 0.12 * error * value;
         }
     }
-    const candidateVector = vectorWithIdf(candidate, transformed.idf);
+    const candidateVector = vectorWithIdf(terms(candidate), transformed.idf);
     const score = bias + Object.entries(candidateVector).reduce((sum, [term, value]) => sum + (weights[term] ?? 0) * value, 0);
     return Number(sigmoid(score).toFixed(3));
 }