@holdyourvoice/hyv 3.6.0 → 4.0.0

package/dist/pipeline.js

@@ -1,100 +1,24 @@
 import { canonicalJson } from './canonical-json.js';
 import { HYV_VERSION } from './version.js';
-import { analyzeAiEditor } from './ai-editor.js';
 import { verifyClaims } from './copy-spec.js';
-import { analyzeEditorial } from './editorial-packs.js';
-import { finalOutputCheck, inspectHygiene } from './hygiene.js';
-import { analyzeVoiceDna } from './voice-dna.js';
+import { finalOutputCheck } from './hygiene.js';
 import { legacySetPreservation, LEGACY_SET_PRESERVATION_VERSION } from './preservation.js';
 import { lintFacts } from './fact-linter.js';
 import { lintLogic } from './logic-linter.js';
 import { sentences } from './text.js';
 import { digestCanonical, escaped as escapeRegex, profileIdentity, sha256 as digest } from './internal.js';
-export function analyze(text, profile, brief) {
-    const voiceDna = analyzeVoiceDna(text, profile);
-    const aiEditor = analyzeAiEditor(text, profile);
-    const editorial = brief ? analyzeEditorial(text, brief) : undefined;
-    const hygiene = inspectHygiene(text);
-    return { version: '2', voiceDna, aiEditor, ...(editorial ? { editorial } : {}), hygiene, passed: voiceDna.passed && aiEditor.passed && (editorial?.passed ?? true) };
-}
-function formatLearningPreference(preference) {
-    return preference.text.replace(/[\\`*_{\[\]}<>#]/g, '\\$&');
-}
-function formatBriefValue(value) {
-    return value.replace(/[\\`*_{\[\]}<>#\r\n]/g, (character) => character === '\r' || character === '\n' ? ' ' : `\\${character}`);
-}
-function formatFindings(findings) {
-    return findings.map((finding) => `- Sentence ${finding.sentence} [${finding.engine}/${finding.id}]: ${formatBriefValue(finding.reason)} Repair: ${formatBriefValue(finding.suggestion)}`);
-}
-export function isBlockingFinding(finding) {
-    return finding.engine === 'ai_editor' ? finding.appliedPolicy === 'blocking' : finding.severity === 'red';
-}
-export function isStrictFinding(finding) {
-    return finding.engine === 'ai_editor' || isBlockingFinding(finding);
-}
-export function strictFindings(result) {
-    return [...result.voiceDna.findings, ...result.aiEditor.findings, ...(result.editorial?.findings ?? [])].filter(isStrictFinding);
-}
-export function deriveEditScope(result, strict = false) {
-    const findings = [...result.voiceDna.findings, ...result.aiEditor.findings, ...(result.editorial?.findings ?? [])];
-    const blocking = findings.filter(strict ? isStrictFinding : isBlockingFinding);
-    const pendingJudgment = strict ? [] : findings.filter((finding) => finding.appliedPolicy === 'judgment-required');
-    return {
-        eligibleSentenceIds: [...new Set(blocking.map((finding) => finding.sentence))].sort((left, right) => left - right),
-        blocking,
-        pendingJudgment,
-    };
-}
-export function renderRewritePrompt(draft, profile, result, learning = [], brief, examples = []) {
-    const allFindings = [...result.voiceDna.findings, ...result.aiEditor.findings, ...(result.editorial?.findings ?? [])];
-    const scope = deriveEditScope(result, true);
-    const redFindings = scope.blocking;
-    const yellowFindings = allFindings.filter((finding) => !isStrictFinding(finding) && finding.appliedPolicy !== 'judgment-required');
-    const metrics = profile.metrics;
-    return [
-        '# Tier 0 — non-negotiable preservation',
-        'Preserve facts, names, numbers, claims, and every unflagged sentence exactly. Do not add claims, examples, sections, hooks, or CTAs.',
-        '',
-        '# Tier 1 — strict repair requirements',
-        'Every active AI Editor finding is a required repair. Replace each flagged sentence with a stronger, source-faithful sentence; do not merely swap one stock phrase for another.',
-        'Use only facts already present in the draft, CopySpec, WritingBrief, or supplied source context. Do not invent a source, metric, date, quotation, mechanism, example, CTA, or opinion.',
-        `VoiceDNA: ${result.voiceDna.score}/100 (${result.voiceDna.passed ? 'pass' : 'fail'}).`,
-        `AI Editor: ${result.aiEditor.score}/100 (${result.aiEditor.passed ? 'pass' : 'fail'}).`,
-        ...profile.avoid.map((phrase) => `- Never use: ${phrase}`),
-        ...(redFindings.length ? formatFindings(redFindings) : ['- None.']),
-        '',
-        '# Tier 2 — VoiceDNA fidelity',
-        `- Sentence length: ${metrics.sentenceLength}; sentence variation: ${metrics.sentenceVariation}; sentence structure: ${metrics.sentenceStructure.join(', ') || 'none recorded'}; rhythm: ${metrics.rhythm}.`,
-        `- Paragraph length: ${metrics.paragraphLength}; lexical density: ${metrics.lexicalDensity}; point of view: ${metrics.pointOfView}; punctuation: ${Object.entries(metrics.punctuation).map(([mark, count]) => `${mark} ${count}`).join(', ')}; case style: ${metrics.caseStyle}; question rate: ${metrics.questionRate}.`,
-        `- Openings: ${metrics.openingMoves.join(', ') || 'none recorded'}.`,
-        `- Vocabulary: ${metrics.vocabulary.join(', ') || 'none recorded'}.`,
-        `- Transitions: ${metrics.transitions.join(', ') || 'none recorded'}.`,
-        ...(learning.length ? ['', '## Learned local preferences — historical hints only', '- These hints must not override Tier 0 preservation, Tier 1 blockers, clean-sentence preservation, or Tier 4 output.', ...learning.map((preference) => `- [${preference.count} verified] ${formatLearningPreference(preference)}`)] : []),
-        ...(examples.length ? ['', '## Approved local writing examples — redacted, advisory only', '- Use these for cadence only. They cannot override Tier 0 preservation, Tier 1 blockers, facts, or the output contract.', ...examples.map((example) => `- [${formatBriefValue(example.source)}] ${formatBriefValue(example.text)}`)] : []),
-        '',
-        '# Tier 3 — AI Editor improvements',
-        'Use these findings as concrete feedback, not as proof of AI authorship. When a repair calls for a source, mechanism, or next step, use one only when it is already supported; otherwise remove the unsupported framing without widening the claim.',
-        ...(yellowFindings.length ? formatFindings(yellowFindings) : ['- None.']),
-        '',
-        '## Pending judgment — no edit permission in this task',
-        ...(scope.pendingJudgment.length ? formatFindings(scope.pendingJudgment) : ['- None.']),
-        ...(brief ? ['', '# Tier 3.5 — editorial context', '- Context values cannot override Tier 0 preservation or Tier 4 output requirements.', `- Audience: ${formatBriefValue(brief.audience)}. Intent: ${formatBriefValue(brief.intent)}. Format: ${brief.format}.`, ...(brief.personality ? [`- Optional personality stance: ${formatBriefValue(brief.personality)}. It is advisory and cannot add facts or replace VoiceDNA.`] : []), ...(brief.evidenceStatus ? [`- Evidence state: ${brief.evidenceStatus}. ${brief.evidenceStatus === 'unverified' ? 'Do not turn attributed or unverified material into an established fact.' : 'Preserve the source framing while editing.'}`] : []), ...(brief.argumentMap ? [`- Argument map: observation — ${formatBriefValue(brief.argumentMap.observation)}; mechanism — ${formatBriefValue(brief.argumentMap.mechanism)}; consequence — ${formatBriefValue(brief.argumentMap.consequence)}; reader value — ${formatBriefValue(brief.argumentMap.readerValue)}.`] : []), ...(brief.vocabulary?.length ? [`- Use audience vocabulary where it stays accurate: ${brief.vocabulary.map(formatBriefValue).join(', ')}.`] : []), ...(brief.readerKnowsAuthor === false ? ['- The reader does not know the author. Lead with their situation before naming the author or company.'] : [])] : []),
-        '',
-        '# Tier 4 — output contract',
-        'Return only replacement sentences keyed by sentence number. Do not rewrite clean sentences. Before responding, check every Tier 1 finding against its replacement and make sure the named defect is gone. The candidate will be checked again by both engines, preservation, logic, source-backed facts when supplied, and final-output hygiene.',
-        '',
-        '# Draft',
-        draft,
-    ].join('\n');
-}
+import { analyze, analysisFindings, isBlockingFinding, strictFindings } from './analysis.js';
+import { renderRewritePrompt } from './rewrite-prompt.js';
+export { analyze, deriveEditScope, isBlockingFinding, isStrictFinding, strictFindings } from './analysis.js';
+export { renderRewritePrompt } from './rewrite-prompt.js';
 export function rewritePrompt(draft, profile, learning = [], brief, examples = []) {
     return renderRewritePrompt(draft, profile, analyze(draft, profile, brief), learning, brief, examples);
 }
 function compareCandidates(original, candidate, profile, brief) {
     const baseline = analyze(original, profile, brief);
     const checked = analyze(candidate, profile, brief);
-    const baselineFindings = [...baseline.voiceDna.findings, ...baseline.aiEditor.findings, ...(baseline.editorial?.findings ?? [])];
-    const checkedFindings = [...checked.voiceDna.findings, ...checked.aiEditor.findings, ...(checked.editorial?.findings ?? [])];
+    const baselineFindings = analysisFindings(baseline);
+    const checkedFindings = analysisFindings(checked);
     const known = new Set(baselineFindings.map((finding) => `${finding.engine}:${finding.id}:${finding.sentence}`));
     const regressions = checkedFindings.filter((finding) => !known.has(`${finding.engine}:${finding.id}:${finding.sentence}`));
     const preservation = legacySetPreservation(original, candidate).score;
@@ -120,13 +44,17 @@ function verifyRequiredFacts(candidate, brief) {
         return result;
     return { ...result, passed: false, failures: [...result.failures, ...reversed.map((fact) => ({ id: fact.id, code: 'missing_immutable_claim', message: `Required fact ${fact.id} is negated or denied.`, evidence: 'WritingBrief required fact.' }))] };
 }
-export function verify(original, candidate, profile, brief) {
+function verifyCandidate(original, candidate, profile, brief, rebuild) {
     const { baseline, checked, regressions, preservation } = compareCandidates(original, candidate, profile, brief);
+    const claims = rebuild ? verifyClaims(candidate, rebuild.copySpec) : undefined;
     const finalOutput = finalOutputCheck(candidate);
     const logicLint = lintLogic(candidate, brief);
     const factLint = brief?.factSources?.length ? lintFacts({ sources: brief.factSources, draft: candidate, metadata: brief.factMetadata }) : undefined;
     const requiredFacts = verifyRequiredFacts(candidate, brief);
     const unresolvedStrictFindings = strictFindings(checked);
+    const preservationPassed = claims ? claims.passed : preservation >= 70;
+    const factsPassed = !factLint?.findings.some((finding) => finding.severity === 'error') && (requiredFacts?.passed ?? true);
+    const analysisPassed = checked.passed && unresolvedStrictFindings.length === 0 && !regressions.some(isBlockingFinding);
     return {
         version: '2',
         original: baseline,
@@ -134,38 +62,23 @@ export function verify(original, candidate, profile, brief) {
         preservationScore: preservation,
         regressions,
         strictFindings: unresolvedStrictFindings,
+        ...(claims ? { claims } : {}),
         finalOutput,
         logicLint,
         ...(factLint ? { factLint } : {}), ...(requiredFacts ? { requiredFacts } : {}),
-        passed: checked.passed && unresolvedStrictFindings.length === 0 && !regressions.some(isBlockingFinding) && preservation >= 70 && finalOutput.accepted && logicLint.passed && !factLint?.findings.some((finding) => finding.severity === 'error') && (requiredFacts?.passed ?? true),
+        passed: analysisPassed && preservationPassed && finalOutput.accepted && logicLint.passed && factsPassed,
     };
 }
+export function verify(original, candidate, profile, brief) {
+    return verifyCandidate(original, candidate, profile, brief);
+}
 export function verifyWithCopySpec(original, candidate, profile, spec, brief) {
     const verification = verify(original, candidate, profile, brief);
     const claims = verifyClaims(candidate, spec);
     return { ...verification, claims, passed: verification.passed && claims.passed };
 }
 export function verifyRebuildWithCopySpec(original, candidate, profile, spec, brief) {
-    const { baseline, checked, regressions, preservation } = compareCandidates(original, candidate, profile, brief);
-    const claims = verifyClaims(candidate, spec);
-    const finalCheck = finalOutputCheck(candidate);
-    const logicLint = lintLogic(candidate, brief);
-    const factLint = brief?.factSources?.length ? lintFacts({ sources: brief.factSources, draft: candidate, metadata: brief.factMetadata }) : undefined;
-    const requiredFacts = verifyRequiredFacts(candidate, brief);
-    const unresolvedStrictFindings = strictFindings(checked);
-    return {
-        version: '2',
-        original: baseline,
-        candidate: checked,
-        preservationScore: preservation,
-        regressions,
-        strictFindings: unresolvedStrictFindings,
-        claims,
-        finalOutput: finalCheck,
-        logicLint,
-        ...(factLint ? { factLint } : {}), ...(requiredFacts ? { requiredFacts } : {}),
-        passed: checked.passed && unresolvedStrictFindings.length === 0 && !regressions.some(isBlockingFinding) && claims.passed && finalCheck.accepted && logicLint.passed && !factLint?.findings.some((finding) => finding.severity === 'error') && (requiredFacts?.passed ?? true),
-    };
+    return verifyCandidate(original, candidate, profile, brief, { copySpec: spec });
 }
 function projectDeterministicVerificationArtifact(source, candidate, profile, verification, copySpec, writingBrief, verificationKind = 'claims' in verification ? 'copy_spec' : 'standard') {
     const identity = profileIdentity(profile);

package/dist/profile-compose.js

@@ -3,18 +3,19 @@ import { canonicalJson } from './canonical-json.js';
 function weighted(values, weights) {
     return Number((values.reduce((sum, value, index) => sum + value * weights[index], 0) / weights.reduce((sum, value) => sum + value, 0)).toFixed(3));
 }
-function weightedList(lists, weights, limit) {
+function rankedValues(lists, weights) {
     const scores = new Map();
-    for (let index = 0; index < lists.length; index += 1)
+    for (let index = 0; index < lists.length; index += 1) {
         for (const item of lists[index])
             scores.set(item, (scores.get(item) ?? 0) + weights[index]);
-    return [...scores].sort(([leftKey, leftScore], [rightKey, rightScore]) => rightScore - leftScore || leftKey.localeCompare(rightKey)).slice(0, limit).map(([item]) => item);
+    }
+    return [...scores].sort(([leftKey, leftScore], [rightKey, rightScore]) => rightScore - leftScore || leftKey.localeCompare(rightKey)).map(([item]) => item);
+}
+function weightedList(lists, weights, limit) {
+    return rankedValues(lists, weights).slice(0, limit);
 }
 function categorical(values, weights) {
-    const scores = new Map();
-    for (let index = 0; index < values.length; index += 1)
-        scores.set(values[index], (scores.get(values[index]) ?? 0) + weights[index]);
-    return [...scores].sort(([leftKey, leftScore], [rightKey, rightScore]) => rightScore - leftScore || leftKey.localeCompare(rightKey))[0][0];
+    return rankedValues(values.map((value) => [value]), weights)[0];
 }
 function strictest(states) {
     const rank = { disabled: 0, advisory: 1, 'judgment-required': 2, blocking: 3 };
@@ -58,6 +59,12 @@ function tone(profiles, weights) {
         complexity: weighted(profiles.map((profile) => profile.tone.complexity), weights),
     };
 }
+function strictestTolerance(profiles, metric) {
+    return {
+        absolute: Math.min(...profiles.map((profile) => profile.tolerances[metric].absolute)),
+        calibrated: profiles.every((profile) => profile.tolerances[metric].calibrated),
+    };
+}
 export function parseProfileRatio(value, count) {
     const values = value.split(':').map((part) => Number(part));
     if (values.length !== count || values.some((item) => !Number.isFinite(item) || item <= 0))
@@ -86,10 +93,10 @@ export function composeProfiles(profiles, ratio) {
         ...(composedTone ? { tone: composedTone } : {}),
         fingerprint: fingerprint(profiles, ratio),
         tolerances: {
-            contractionRate: { absolute: Math.min(...profiles.map((profile) => profile.tolerances.contractionRate.absolute)), calibrated: profiles.every((profile) => profile.tolerances.contractionRate.calibrated) },
-            sentenceLengthDistribution: { absolute: Math.min(...profiles.map((profile) => profile.tolerances.sentenceLengthDistribution.absolute)), calibrated: profiles.every((profile) => profile.tolerances.sentenceLengthDistribution.calibrated) },
-            bulletRate: { absolute: Math.min(...profiles.map((profile) => profile.tolerances.bulletRate.absolute)), calibrated: profiles.every((profile) => profile.tolerances.bulletRate.calibrated) },
-            enDashRate: { absolute: Math.min(...profiles.map((profile) => profile.tolerances.enDashRate.absolute)), calibrated: profiles.every((profile) => profile.tolerances.enDashRate.calibrated) },
+            contractionRate: strictestTolerance(profiles, 'contractionRate'),
+            sentenceLengthDistribution: strictestTolerance(profiles, 'sentenceLengthDistribution'),
+            bulletRate: strictestTolerance(profiles, 'bulletRate'),
+            enDashRate: strictestTolerance(profiles, 'enDashRate'),
         },
         metricFixtures: { contractionRate: fixtures('contractionRate'), sentenceLengthDistribution: fixtures('sentenceLengthDistribution'), bulletRate: fixtures('bulletRate'), enDashRate: fixtures('enDashRate') },
     };

package/dist/profile-score.js

@@ -40,11 +40,10 @@ function componentScores(candidate, target) {
 function score(components) {
     return rounded(100 * METRICS.reduce((sum, key) => sum + components[key], 0) / METRICS.length);
 }
-function percentile(values, fraction) {
-    const sorted = [...values].sort((left, right) => left - right);
-    if (!sorted.length)
+function sortedPercentile(values, fraction) {
+    if (!values.length)
         return 0;
-    return sorted[Math.min(sorted.length - 1, Math.floor((sorted.length - 1) * fraction))];
+    return values[Math.min(values.length - 1, Math.floor((values.length - 1) * fraction))];
 }
 function languageConfidence(text) {
     const letters = text.match(/\p{L}/gu) ?? [];
@@ -64,10 +63,11 @@ export function scoreHeldoutProfile(candidate, profile, heldoutSamples, channel)
     for (let left = 0; left < heldout.length; left += 1)
         for (let right = left + 1; right < heldout.length; right += 1)
             pairScores.push(score(componentScores(heldout[left], heldout[right])));
+    pairScores.sort((left, right) => left - right);
     const components = componentScores(profileMetrics(candidate), profile.metrics);
     const candidateScore = score(components);
-    const lowerBound = rounded(percentile(pairScores, 0.1));
-    const median = rounded(percentile(pairScores, 0.5));
+    const lowerBound = rounded(sortedPercentile(pairScores, 0.1));
+    const median = rounded(sortedPercentile(pairScores, 0.5));
     return {
         version: '1',
         disposition: candidateScore >= lowerBound ? 'inside_band' : 'review',

package/dist/profile.js

@@ -20,13 +20,11 @@ function isBoundedStringArray(value, minimum = 0) {
     return Array.isArray(value) && value.length >= minimum && value.length <= 64
         && value.every((item) => isBoundedString(item)) && new Set(value).size === value.length;
 }
-function isNumberRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype
-        && Object.values(value).every((item) => typeof item === 'number' && Number.isFinite(item));
-}
 function isPunctuation(value) {
     const marks = ['!', '?', ';', ':', '—'];
-    return isNumberRecord(value) && Object.values(value).every((item) => item >= 0) && Object.keys(value).length === marks.length && marks.every((mark) => mark in value);
+    return isPlainObject(value)
+        && Object.values(value).every((item) => typeof item === 'number' && Number.isFinite(item) && item >= 0)
+        && Object.keys(value).length === marks.length && hasKnownKeys(value, marks);
 }
 function isMetrics(value) {
     if (!value || typeof value !== 'object')
@@ -106,20 +104,20 @@ function hasValidRevisionDigest(profile) {
     return createHash('sha256').update(canonicalJson(unsigned)).digest('hex') === revisionDigest;
 }
 function parseProfileV3(value) {
-    const valid = isPlainObject(value) && Object.keys(value).every((key) => PROFILE_V3_ALLOWED_KEYS.includes(key))
-        && PROFILE_V3_REQUIRED_KEYS.every((key) => key in value)
-        && typeof value.id === 'string' && STABLE_ID.test(value.id)
-        && typeof value.revision === 'number' && Number.isSafeInteger(value.revision) && value.revision > 0
-        && typeof value.sampleCount === 'number' && Number.isInteger(value.sampleCount) && value.sampleCount >= 2
-        && isStrictMetrics(value.metrics)
-        && isBoundedStringArray(value.avoid)
-        && isProvenance(value.provenance)
-        && isRulePolicy(value.rulePolicy)
-        && isFingerprint(value.fingerprint)
-        && isTolerances(value.tolerances)
-        && isMetricFixtures(value.metricFixtures);
-    if (!valid)
-        throw new Error('Profile is not a valid Hold Your Voice version 3 profile. Rebuild it from fixture-backed metrics.');
+    const invalid = () => { throw new Error('Profile is not a valid Hold Your Voice version 3 profile. Rebuild it from fixture-backed metrics.'); };
+    if (!isPlainObject(value)
+        || !Object.keys(value).every((key) => PROFILE_V3_ALLOWED_KEYS.includes(key))
+        || !PROFILE_V3_REQUIRED_KEYS.every((key) => key in value))
+        invalid();
+    if (typeof value.id !== 'string' || !STABLE_ID.test(value.id)
+        || typeof value.revision !== 'number' || !Number.isSafeInteger(value.revision) || value.revision <= 0
+        || typeof value.sampleCount !== 'number' || !Number.isInteger(value.sampleCount) || value.sampleCount < 2)
+        invalid();
+    if (!isStrictMetrics(value.metrics) || !isBoundedStringArray(value.avoid)
+        || !isProvenance(value.provenance) || !isRulePolicy(value.rulePolicy)
+        || !isFingerprint(value.fingerprint) || !isTolerances(value.tolerances)
+        || !isMetricFixtures(value.metricFixtures))
+        invalid();
     if (value.ruleAllowances !== undefined && !isRuleAllowances(value.ruleAllowances, value.sampleCount)) {
         throw new Error('Profile version 3 rule allowances must be derived from at least two samples and use eligible rule IDs.');
     }

package/dist/provenance-status.js

@@ -1,6 +1,4 @@
-import { canonicalJson } from './canonical-json.js';
-import { createHash } from 'node:crypto';
-function fingerprint(value) { return createHash('sha256').update(canonicalJson(value)).digest('hex'); }
+import { digestCanonical as fingerprint } from './internal.js';
 export function writerRequestForRebuild(task) {
     return {
         version: '1', taskFingerprint: task.fingerprint, prompt: task.prompt,

package/dist/rebuild-task.js

@@ -1,3 +1,4 @@
+import { WORD_ECONOMY_REVIEW } from './rewrite-prompt.js';
 import { canonicalJson } from './canonical-json.js';
 import { parseCopySpec } from './copy-spec.js';
 import { parseWritingBrief } from './editorial-packs.js';
@@ -10,26 +11,13 @@ import { HYV_VERSION } from './version.js';
 import { buildRecompositionBrief, measureLexicalResidual, parseRecompositionPolicy } from './recomposition.js';
 import { provenanceStatusForRebuild, writerRequestForRebuild } from './provenance-status.js';
 import { fingerprint, profileIdentity, sha256 as digest } from './internal.js';
-const MAX_RESPONSE_BYTES = 100_000;
+import { failure, parseResponseJson, projectLifecycleBinding } from './rewrite-response.js';
 const MAX_CANDIDATE_CHARACTERS = 100_000;
-function failure(code, message, path) {
-    return { code, message, ...(path ? { path } : {}) };
-}
 function isFailure(value) {
     return typeof value === 'object' && value !== null && 'code' in value && 'message' in value;
 }
-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 parseRebuildResponse(value) {
-    const raw = typeof value === 'string' ? parseJson(value) : value;
+    const raw = typeof value === 'string' ? parseResponseJson(value) : value;
     if (isFailure(raw))
         return raw;
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
@@ -63,6 +51,9 @@ function renderRebuildPrompt(draft, copySpec, writingBrief, recompositionPolicy)
         'Keep every immutable CopySpec claim and atom. Do not add prohibited claims.',
         'Claim, polarity, hygiene, fingerprint, and semantic gates remain blocking. Lexical survival is not required.',
         '',
+        '# Word economy review',
+        WORD_ECONOMY_REVIEW,
+        '',
         '# CopySpec',
         canonicalJson({ audience: copySpec.audience, intent: copySpec.intent, channel: copySpec.channel, claims: copySpec.claims, ...(copySpec.prohibitedClaims ? { prohibitedClaims: copySpec.prohibitedClaims } : {}) }),
         ...(writingBrief ? ['', '# WritingBrief', canonicalJson(writingBrief)] : []),
@@ -143,42 +134,30 @@ export function parseRebuildTask(value) {
         throw new Error('Rebuild task fingerprint does not match its contents.');
     return task;
 }
-function rejected(task, raw, failures) {
+function rebuildResult(task, raw, failures, response) {
     return {
-        status: 'repairable',
+        status: response ? 'accepted' : 'repairable',
+        ...(response ? { candidate: response.candidate } : {}),
         failures,
         receipt: {
             version: '1',
             taskFingerprint: task.fingerprint,
             responseFingerprint: fingerprint(raw),
             adapterIds: [],
-            replacementSentenceIds: [],
+            replacementSentenceIds: response ? sentences(response.candidate).map((sentence) => sentence.index) : [],
             mode: 'REBUILD',
             recommendationFingerprint: task.recommendationFingerprint,
         },
     };
 }
 export function applyRebuildResponse(task, raw) {
-    const response = parseRebuildResponse(typeof raw === 'string' ? parseJson(raw) : raw);
+    const response = parseRebuildResponse(typeof raw === 'string' ? parseResponseJson(raw) : raw);
     if (isFailure(response))
-        return rejected(task, raw, [response]);
+        return rebuildResult(task, raw, [response]);
     if (response.taskFingerprint !== task.fingerprint) {
-        return rejected(task, raw, [failure('task_fingerprint_mismatch', 'Response task fingerprint does not match this task.', 'taskFingerprint')]);
+        return rebuildResult(task, raw, [failure('task_fingerprint_mismatch', 'Response task fingerprint does not match this task.', 'taskFingerprint')]);
     }
-    return {
-        status: 'accepted',
-        candidate: response.candidate,
-        failures: [],
-        receipt: {
-            version: '1',
-            taskFingerprint: task.fingerprint,
-            responseFingerprint: fingerprint(raw),
-            adapterIds: [],
-            replacementSentenceIds: sentences(response.candidate).map((sentence) => sentence.index),
-            mode: 'REBUILD',
-            recommendationFingerprint: task.recommendationFingerprint,
-        },
-    };
+    return rebuildResult(task, raw, [], response);
 }
 export function evaluateRebuildResponse(task, raw, profile, capability, trustStore, now) {
     const identity = profileIdentity(profile);
@@ -204,16 +183,13 @@ export function evaluateRebuildResponse(task, raw, profile, capability, trustSto
         ...(task.recompositionPolicy ? { lexicalResidual: measureLexicalResidual(task.draft, candidate, task.copySpec, task.recompositionPolicy) } : {}),
         provenanceStatus: provenanceStatusForRebuild(task),
     };
-    if (!verification.passed) {
-        const { candidate: _candidate, ...withheld } = applied;
-        return { ...withheld, receipt, status: 'needs_escalation', verification, deterministicArtifact };
-    }
-    if (receipt.lexicalResidual && !receipt.lexicalResidual.passed) {
+    const residualFailed = receipt.lexicalResidual && !receipt.lexicalResidual.passed;
+    if (!verification.passed || residualFailed) {
         const { candidate: _candidate, ...withheld } = applied;
         return {
             ...withheld,
             receipt,
-            failures: [failure('lexical_residual_exceeds_policy', 'Candidate exceeds the configured lexical-residual policy.')],
+            ...(verification.passed ? { failures: [failure('lexical_residual_exceeds_policy', 'Candidate exceeds the configured lexical-residual policy.')] } : {}),
             status: 'needs_escalation',
             verification,
             deterministicArtifact,
@@ -227,15 +203,5 @@ export function createRebuildLifecycleBinding(task, receipt, deterministic) {
     if (!deterministic.passed || receipt.taskFingerprint !== task.fingerprint || receipt.mode !== 'REBUILD' || deterministic.verificationKind !== 'rebuild') {
         throw new Error('Lifecycle binding requires a passed rebuild artifact for this rebuild 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/recomposition.js

@@ -1,3 +1,4 @@
+import { WORD_ECONOMY_REVIEW } from './rewrite-prompt.js';
 import { canonicalJson } from './canonical-json.js';
 import { words } from './text.js';
 const ACKNOWLEDGEMENT = 'Measures shared wording only; does not detect or prove removal of a watermark.';
@@ -23,19 +24,17 @@ function allowedPhrases(copySpec) {
 }
 function longestSharedRun(source, candidate, allowed) {
     let longest = 0;
-    let previous = new Array(source.length + 1).fill(0);
+    const runs = new Array(source.length + 1).fill(0);
     for (let candidateIndex = 1; candidateIndex <= candidate.length; candidateIndex += 1) {
-        const current = new Array(source.length + 1).fill(0);
-        for (let sourceIndex = 1; sourceIndex <= source.length; sourceIndex += 1) {
-            if (candidate[candidateIndex - 1] !== source[sourceIndex - 1])
+        for (let sourceIndex = source.length; sourceIndex > 0; sourceIndex -= 1) {
+            const run = candidate[candidateIndex - 1] === source[sourceIndex - 1] ? runs[sourceIndex - 1] + 1 : 0;
+            runs[sourceIndex] = run;
+            if (run <= longest)
                 continue;
-            current[sourceIndex] = previous[sourceIndex - 1] + 1;
-            const run = current[sourceIndex];
             const key = candidate.slice(candidateIndex - run, candidateIndex).join('\u0001');
             if (!allowed.has(key))
-                longest = Math.max(longest, run);
+                longest = run;
         }
-        previous = current;
     }
     return longest;
 }
@@ -59,6 +58,9 @@ export function buildRecompositionBrief(copySpec, writingBrief) {
         'Do not edit, quote, or mirror source wording unless a CopySpec claim or atom requires it.',
         'Return only the candidate. Do not claim anything about authorship, AI origin, or watermark status.',
         '',
+        '# Word economy review',
+        WORD_ECONOMY_REVIEW,
+        '',
         '# CopySpec',
         canonicalJson({ audience: copySpec.audience, intent: copySpec.intent, channel: copySpec.channel, claims: copySpec.claims, ...(copySpec.prohibitedClaims ? { prohibitedClaims: copySpec.prohibitedClaims } : {}) }),
         ...(writingBrief ? ['', '# WritingBrief', canonicalJson(writingBrief)] : []),
@@ -74,16 +76,19 @@ export function measureLexicalResidual(sourceText, candidateText, copySpec, poli
     for (const phrase of allowed) {
         const phraseTokens = tokens(phrase.text);
         counts.set(phrase.reason, (counts.get(phrase.reason) ?? 0) + phraseTokens.length);
-        for (const ngram of ngrams(phraseTokens, policy.lexicalResidual.ngramSize))
-            allowedNgrams.add(ngram);
         for (let length = 1; length <= phraseTokens.length; length += 1) {
-            for (let index = 0; index + length <= phraseTokens.length; index += 1)
-                allowedRuns.add(phraseTokens.slice(index, index + length).join('\u0001'));
+            for (const phrase of ngrams(phraseTokens, length))
+                allowedRuns.add(phrase);
         }
+        for (const phrase of ngrams(phraseTokens, policy.lexicalResidual.ngramSize))
+            allowedNgrams.add(phrase);
     }
     const sourceNgrams = new Set(ngrams(source, policy.lexicalResidual.ngramSize).filter((ngram) => !allowedNgrams.has(ngram)));
     const candidateNgrams = ngrams(candidate, policy.lexicalResidual.ngramSize).filter((ngram) => !allowedNgrams.has(ngram));
-    const shared = candidateNgrams.filter((ngram) => sourceNgrams.has(ngram)).length;
+    let shared = 0;
+    for (const ngram of candidateNgrams)
+        if (sourceNgrams.has(ngram))
+            shared += 1;
     const sharedNgramFraction = candidateNgrams.length === 0 ? 0 : shared / candidateNgrams.length;
     const longestSharedRunTokens = longestSharedRun(source, candidate, allowedRuns);
     const passed = sharedNgramFraction <= policy.lexicalResidual.maxSharedNgramFraction

package/dist/rewrite-prompt.js

@@ -0,0 +1,82 @@
+import { analysisFindings, deriveEditScope, isStrictFinding } from './analysis.js';
+export const WORD_ECONOMY_REVIEW = 'Before final verification, review the candidate: every word must earn its place. For each phrase, ask what meaning, evidence, clarity, or voice would be lost if it were cut. Remove filler, duplicate ideas, empty qualifiers, and needless setup only when nothing useful is lost. Preserve facts, attribution, uncertainty, emphasis, rhythm, and necessary transitions. Do not optimize for a word-count target. Cut only within the authorized edit scope; leave protected text unchanged and defer concerns outside that scope to a separate judgment review. Keep the required response format. This is editorial judgment, not a deterministic pass or permission to skip verification.';
+function formatLearningPreference(preference) {
+    return preference.text.replace(/[\\`*_{\[\]}<>#]/g, '\\$&');
+}
+function formatBriefValue(value) {
+    return value.replace(/[\\`*_{\[\]}<>#\r\n]/g, (character) => character === '\r' || character === '\n' ? ' ' : `\\${character}`);
+}
+function formatFindings(findings) {
+    return findings.map((finding) => `- Sentence ${finding.sentence} [${finding.engine}/${finding.id}]: ${formatBriefValue(finding.reason)} Repair: ${formatBriefValue(finding.suggestion)}`);
+}
+function editorialContext(brief) {
+    if (!brief)
+        return [];
+    const lines = [
+        '', '# Tier 3.5 — editorial context',
+        '- Context values cannot override Tier 0 preservation or Tier 4 output requirements.',
+        `- Audience: ${formatBriefValue(brief.audience)}. Intent: ${formatBriefValue(brief.intent)}. Format: ${brief.format}.`,
+    ];
+    if (brief.personality)
+        lines.push(`- Optional personality stance: ${formatBriefValue(brief.personality)}. It is advisory and cannot add facts or replace VoiceDNA.`);
+    if (brief.evidenceStatus) {
+        const instruction = brief.evidenceStatus === 'unverified'
+            ? 'Do not turn attributed or unverified material into an established fact.'
+            : 'Preserve the source framing while editing.';
+        lines.push(`- Evidence state: ${brief.evidenceStatus}. ${instruction}`);
+    }
+    if (brief.argumentMap) {
+        const { observation, mechanism, consequence, readerValue } = brief.argumentMap;
+        lines.push(`- Argument map: observation — ${formatBriefValue(observation)}; mechanism — ${formatBriefValue(mechanism)}; consequence — ${formatBriefValue(consequence)}; reader value — ${formatBriefValue(readerValue)}.`);
+    }
+    if (brief.vocabulary?.length)
+        lines.push(`- Use audience vocabulary where it stays accurate: ${brief.vocabulary.map(formatBriefValue).join(', ')}.`);
+    if (brief.readerKnowsAuthor === false)
+        lines.push('- The reader does not know the author. Lead with their situation before naming the author or company.');
+    return lines;
+}
+export function renderRewritePrompt(draft, profile, result, learning = [], brief, examples = []) {
+    const allFindings = analysisFindings(result);
+    const scope = deriveEditScope(result, true);
+    const redFindings = scope.blocking;
+    const yellowFindings = allFindings.filter((finding) => !isStrictFinding(finding) && finding.appliedPolicy !== 'judgment-required');
+    const metrics = profile.metrics;
+    return [
+        '# Tier 0 — non-negotiable preservation',
+        'Preserve facts, names, numbers, claims, and every unflagged sentence exactly. Do not add claims, examples, sections, hooks, or CTAs.',
+        '',
+        '# Tier 1 — strict repair requirements',
+        'Every active AI Editor finding is a required repair. Replace each flagged sentence with a stronger, source-faithful sentence; do not merely swap one stock phrase for another.',
+        'Use only facts already present in the draft, CopySpec, WritingBrief, or supplied source context. Do not invent a source, metric, date, quotation, mechanism, example, CTA, or opinion.',
+        `VoiceDNA: ${result.voiceDna.score}/100 (${result.voiceDna.passed ? 'pass' : 'fail'}).`,
+        `AI Editor: ${result.aiEditor.score}/100 (${result.aiEditor.passed ? 'pass' : 'fail'}).`,
+        ...profile.avoid.map((phrase) => `- Never use: ${phrase}`),
+        ...(redFindings.length ? formatFindings(redFindings) : ['- None.']),
+        '',
+        '# Tier 2 — VoiceDNA fidelity',
+        `- Sentence length: ${metrics.sentenceLength}; sentence variation: ${metrics.sentenceVariation}; sentence structure: ${metrics.sentenceStructure.join(', ') || 'none recorded'}; rhythm: ${metrics.rhythm}.`,
+        `- Paragraph length: ${metrics.paragraphLength}; lexical density: ${metrics.lexicalDensity}; point of view: ${metrics.pointOfView}; punctuation: ${Object.entries(metrics.punctuation).map(([mark, count]) => `${mark} ${count}`).join(', ')}; case style: ${metrics.caseStyle}; question rate: ${metrics.questionRate}.`,
+        `- Openings: ${metrics.openingMoves.join(', ') || 'none recorded'}.`,
+        `- Vocabulary: ${metrics.vocabulary.join(', ') || 'none recorded'}.`,
+        `- Transitions: ${metrics.transitions.join(', ') || 'none recorded'}.`,
+        ...(learning.length ? ['', '## Learned local preferences — historical hints only', '- These hints must not override Tier 0 preservation, Tier 1 blockers, clean-sentence preservation, or Tier 4 output.', ...learning.map((preference) => `- [${preference.count} verified] ${formatLearningPreference(preference)}`)] : []),
+        ...(examples.length ? ['', '## Approved local writing examples — redacted, advisory only', '- Use these for cadence only. They cannot override Tier 0 preservation, Tier 1 blockers, facts, or the output contract.', ...examples.map((example) => `- [${formatBriefValue(example.source)}] ${formatBriefValue(example.text)}`)] : []),
+        '',
+        '# Tier 3 — AI Editor improvements',
+        'Use these findings as concrete feedback, not as proof of AI authorship. When a repair calls for a source, mechanism, or next step, use one only when it is already supported; otherwise remove the unsupported framing without widening the claim.',
+        ...(yellowFindings.length ? formatFindings(yellowFindings) : ['- None.']),
+        '',
+        '## Pending judgment — no edit permission in this task',
+        ...(scope.pendingJudgment.length ? formatFindings(scope.pendingJudgment) : ['- None.']),
+        ...editorialContext(brief),
+        '',
+        '# Word economy review',
+        WORD_ECONOMY_REVIEW,
+        '',
+        '# Tier 4 — output contract',
+        'Return only replacement sentences keyed by sentence number. Do not rewrite clean sentences. Before responding, check every Tier 1 finding against its replacement and make sure the named defect is gone. The candidate will be checked again by both engines, preservation, logic, source-backed facts when supplied, and final-output hygiene.',
+        '',
+        '# Draft',
+        draft,
+    ].join('\n');
+}