@holdyourvoice/hyv 3.2.0 → 3.3.0

package/dist/mcp.test.js

@@ -1,12 +1,54 @@
 import assert from 'node:assert/strict';
+import { createHash, generateKeyPairSync, sign } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { once } from 'node:events';
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
 import { profileFingerprint } from './learning.js';
 import { buildProfile } from './voice-dna.js';
+import { canonicalJson } from './canonical-json.js';
+import { applyRewriteForMcp, prepareLifecycleForMcp, prepareRewriteForMcp } from './mcp-tools.js';
+function profileV3Json() {
+    const profile = buildProfile(['I write plainly. I name the work.', 'I keep the mechanism clear. I avoid filler.'], ['leverage']);
+    const unsigned = { ...profile, version: '3', id: 'founder.test', revision: 1, provenance: { source: 'test', rights: 'test', createdAt: '2026-08-13T00:00:00.000Z' }, rulePolicy: {}, fingerprint: { contractionRate: 0, sentenceLengthDistribution: { short: 1, medium: 0, long: 0 }, bulletRate: 0, enDashRate: 0 }, tolerances: { contractionRate: { absolute: 0.1, calibrated: false }, sentenceLengthDistribution: { absolute: 0.1, calibrated: false }, bulletRate: { absolute: 0.1, calibrated: false }, enDashRate: { absolute: 0.1, calibrated: false } }, metricFixtures: { contractionRate: ['test'], sentenceLengthDistribution: ['test'], bulletRate: ['test'], enDashRate: ['test'] } };
+    const canonical = (value) => Array.isArray(value) ? `[${value.map(canonical).join(',')}]` : value && typeof value === 'object' ? `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}` : JSON.stringify(value);
+    return JSON.stringify({ ...unsigned, revisionDigest: createHash('sha256').update(canonical(unsigned)).digest('hex') });
+}
+async function callMcp(tools, env = process.env) {
+    const server = spawn(process.execPath, [new URL('./cli.js', import.meta.url).pathname, 'mcp'], { stdio: ['pipe', 'pipe', 'pipe'], env });
+    let stdout = '';
+    let stderr = '';
+    server.stdout.on('data', (chunk) => { stdout += chunk; });
+    server.stderr.on('data', (chunk) => { stderr += chunk; });
+    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'test', version: '1.0.0' } } })}\n`);
+    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} })}\n`);
+    tools.forEach((tool, index) => server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: index + 2, method: 'tools/call', params: tool })}\n`));
+    server.stdin.end();
+    const [code] = await once(server, 'close');
+    assert.equal(code, 0);
+    assert.equal(stderr, '');
+    return stdout.trim().split('\n').map((line) => JSON.parse(line)).filter((response) => response.id >= 2).sort((a, b) => a.id - b.id);
+}
+function toolPayload(response) {
+    return JSON.parse(response.result?.content?.[0]?.text ?? '{}');
+}
+function installedContextEnvironment(root, context) {
+    const home = join(root, 'home');
+    const config = join(home, '.config', 'holdyourvoice');
+    mkdirSync(config, { recursive: true, mode: 0o700 });
+    const contextPath = join(config, 'approval-context.json');
+    writeFileSync(contextPath, canonicalJson(context), { mode: 0o600 });
+    chmodSync(contextPath, 0o600);
+    const fakeOs = join(root, 'fake-os.mjs');
+    const hooks = join(root, 'hooks.mjs');
+    const register = join(root, 'register.mjs');
+    writeFileSync(fakeOs, `import * as actual from 'node:os'; export const userInfo = () => ({ ...actual.userInfo(), homedir: process.env.HYV_TEST_HOME });\n`);
+    writeFileSync(hooks, `export async function resolve(specifier, context, nextResolve) { if (specifier === 'node:os' && context.parentURL?.endsWith('/approval-context.js')) return { url: new URL('./fake-os.mjs', import.meta.url).href, shortCircuit: true }; return nextResolve(specifier, context); }\n`);
+    writeFileSync(register, `import { register } from 'node:module'; register(new URL('./hooks.mjs', import.meta.url));\n`);
+    return { ...process.env, NODE_NO_WARNINGS: '1', NODE_OPTIONS: `--import=${register}`, HYV_TEST_HOME: home };
+}
 test('serves local Claude tools over stdio', async () => {
     const server = spawn(process.execPath, [new URL('./cli.js', import.meta.url).pathname, 'mcp'], { stdio: ['pipe', 'pipe', 'pipe'] });
     let stdout = '';
@@ -22,10 +64,170 @@ test('serves local Claude tools over stdio', async () => {
     assert.equal(code, 0);
     const responses = stdout.trim().split('\n').map((line) => JSON.parse(line));
     const tools = responses.find((response) => response.id === 2)?.result?.tools;
-    assert.deepEqual(tools?.map((tool) => tool.name), ['hyv_build_profile', 'hyv_analyze', 'hyv_hygiene', 'hyv_final_check', 'hyv_rewrite_prompt', 'hyv_prepare_rewrite', 'hyv_apply_rewrite', 'hyv_verify', 'hyv_verify_copy_spec', 'hyv_batch_analyze', 'hyv_patterns']);
-    assert.ok(tools?.filter((tool) => tool.name !== 'hyv_verify' && tool.name !== 'hyv_verify_copy_spec').every((tool) => tool.annotations?.readOnlyHint));
-    assert.equal(tools?.find((tool) => tool.name === 'hyv_verify')?.annotations?.readOnlyHint, false);
-    assert.equal(tools?.find((tool) => tool.name === 'hyv_verify_copy_spec')?.annotations?.readOnlyHint, false);
+    assert.deepEqual(tools?.map((tool) => tool.name), ['hyv_build_profile', 'hyv_analyze', 'hyv_hygiene', 'hyv_final_check', 'hyv_rewrite_prompt', 'hyv_prepare_rewrite', 'hyv_apply_rewrite', 'hyv_prepare_judgment', 'hyv_reduce_judgment', 'hyv_verify', 'hyv_verify_copy_spec', 'hyv_batch_analyze', 'hyv_patterns', 'hyv_learning_inspect', 'hyv_learning_record', 'hyv_learning_ratify', 'hyv_learning_supersede', 'hyv_learning_migrate', 'hyv_learning_clear', 'hyv_lifecycle_prepare_semantic', 'hyv_lifecycle_submit_verdict', 'hyv_lifecycle_inspect', 'hyv_lifecycle_finalize']);
+    assert.ok(tools?.filter((tool) => !['hyv_verify', 'hyv_verify_copy_spec', 'hyv_learning_record', 'hyv_learning_ratify', 'hyv_learning_supersede', 'hyv_learning_migrate', 'hyv_learning_clear'].includes(tool.name)).every((tool) => tool.annotations?.readOnlyHint));
+    assert.equal(tools?.find((tool) => tool.name === 'hyv_verify')?.annotations?.readOnlyHint, true);
+    assert.equal(tools?.find((tool) => tool.name === 'hyv_verify_copy_spec')?.annotations?.readOnlyHint, true);
+    assert.equal(tools?.some((tool) => tool.name === 'hyv_lifecycle_validate_final_approval'), false);
+    assert.equal(tools?.some((tool) => tool.name === 'hyv_learning_record_approved'), false);
+    assert.equal(tools?.some((tool) => tool.name === 'hyv_prepare_rebuild'), false);
+    assert.equal(tools?.some((tool) => tool.name === 'hyv_apply_rebuild'), false);
+    assert.equal('capability_json' in (tools?.find((tool) => tool.name === 'hyv_lifecycle_finalize')?.inputSchema?.properties ?? {}), false);
+    assert.equal(tools?.find((tool) => tool.name === 'hyv_learning_inspect')?.annotations?.readOnlyHint, true);
+    assert.equal(tools?.find((tool) => tool.name === 'hyv_learning_clear')?.annotations?.readOnlyHint, false);
+    assert.deepEqual(tools?.filter((tool) => tool.name.startsWith('hyv_learning_')).map((tool) => [tool.name, tool.annotations?.readOnlyHint, tool.annotations?.destructiveHint]), [
+        ['hyv_learning_inspect', true, undefined], ['hyv_learning_record', false, false], ['hyv_learning_ratify', false, false],
+        ['hyv_learning_supersede', false, true], ['hyv_learning_migrate', false, false], ['hyv_learning_clear', false, true],
+    ]);
+});
+test('registers capability tools only with host redaction attestation', async () => {
+    const server = spawn(process.execPath, [new URL('./cli.js', import.meta.url).pathname, 'mcp'], { stdio: ['pipe', 'pipe', 'pipe'], env: { ...process.env, HYV_MCP_SENSITIVE_INPUT_REDACTION: '1' } });
+    let stdout = '';
+    let stderr = '';
+    server.stdout.on('data', (chunk) => { stdout += chunk; });
+    server.stderr.on('data', (chunk) => { stderr += chunk; });
+    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'test', version: '1.0.0' } } })}\n`);
+    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} })}\n`);
+    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} })}\n`);
+    server.stdin.end();
+    const [code] = await once(server, 'close');
+    assert.equal(code, 0);
+    assert.equal(stderr, '');
+    const response = stdout.trim().split('\n').map((line) => JSON.parse(line)).find((item) => item.id === 2);
+    const names = response.result.tools.map((tool) => tool.name);
+    assert.equal(names.length, 27);
+    assert.ok(names.includes('hyv_lifecycle_validate_final_approval'));
+    assert.ok(names.includes('hyv_learning_record_approved'));
+    assert.ok(names.includes('hyv_prepare_rebuild'));
+    assert.ok(names.includes('hyv_apply_rebuild'));
+    const finalize = response.result.tools.find((tool) => tool.name === 'hyv_lifecycle_finalize');
+    assert.equal('capability_json' in finalize.inputSchema.properties, true);
+});
+test('redacts rebuild prepare transport failures', async () => {
+    const secret = 'rebuild-prepare-secret-nonce';
+    const responses = await callMcp([{ name: 'hyv_prepare_rebuild', arguments: { draft: 'x', profile_json: '{}', reduction_json: '{}', copy_spec_json: '{}', capability_json: JSON.stringify({ payload: secret, signature: secret }) } }], { ...process.env, HYV_MCP_SENSITIVE_INPUT_REDACTION: '1' });
+    const serialized = JSON.stringify(responses[0]);
+    assert.equal(responses[0]?.result?.isError, true);
+    assert.doesNotMatch(serialized, new RegExp(secret));
+    assert.match(serialized, /Rebuild preparation failed/);
+});
+test('redacts rebuild apply transport failures', async () => {
+    const secret = 'rebuild-apply-secret-nonce';
+    const responses = await callMcp([{ name: 'hyv_apply_rebuild', arguments: { task_json: '{}', response_json: '{}', profile_json: '{}', capability_json: JSON.stringify({ payload: secret, signature: secret }) } }], { ...process.env, HYV_MCP_SENSITIVE_INPUT_REDACTION: '1' });
+    const serialized = JSON.stringify(responses[0]);
+    assert.equal(responses[0]?.result?.isError, true);
+    assert.doesNotMatch(serialized, new RegExp(secret));
+    assert.match(serialized, /Rebuild application failed/);
+});
+test('redacts capability-bearing transport failures', async () => {
+    const secret = 'transport-secret-nonce';
+    const responses = await callMcp([{ name: 'hyv_lifecycle_validate_final_approval', arguments: { artifact_json: '{}', capability_json: JSON.stringify({ payload: secret, signature: secret }) } }], { ...process.env, HYV_MCP_SENSITIVE_INPUT_REDACTION: '1' });
+    const serialized = JSON.stringify(responses[0]);
+    assert.equal(responses[0]?.result?.isError, true);
+    assert.doesNotMatch(serialized, new RegExp(secret));
+    assert.match(serialized, /Capability validation failed/);
+});
+test('runs registered lifecycle preparation and inspection over stdio', async () => {
+    const base = { version: '1', verificationKind: 'standard', passed: true, analysisVersion: '2', rulesetVersion: '3.2.0', preservationMetricVersion: 'legacy-set-v1', preservationScore: 100, sourceHash: '4'.repeat(64), candidateHash: '5'.repeat(64), profileId: 'founder.primary', profileRevisionDigest: '6'.repeat(64), regressionKeys: [] };
+    const deterministic = { ...base, artifactFingerprint: createHash('sha256').update(`hyv:deterministic-verification:v1\0${canonicalJson(base)}`).digest('hex') };
+    const binding = { rewriteTaskFingerprint: '1'.repeat(64), rewriteResponseFingerprint: '2'.repeat(64), deterministicArtifactFingerprint: deterministic.artifactFingerprint, sourceHash: deterministic.sourceHash, candidateHash: deterministic.candidateHash, profileId: deterministic.profileId, profileRevisionDigest: deterministic.profileRevisionDigest, rulesetVersion: deterministic.rulesetVersion, schemaVersion: '1' };
+    const receipt = { version: '1', taskFingerprint: binding.rewriteTaskFingerprint, responseFingerprint: binding.rewriteResponseFingerprint, adapterIds: [], replacementSentenceIds: [1] };
+    const preparedResponse = await callMcp([{ name: 'hyv_lifecycle_prepare_semantic', arguments: { deterministic_json: JSON.stringify(deterministic), binding_json: JSON.stringify(binding), receipt_json: JSON.stringify(receipt), policy: 'normal', allowed_violations: ['action_change'] } }], { ...process.env, HYV_MCP_SENSITIVE_INPUT_REDACTION: '' });
+    const prepared = toolPayload(preparedResponse[0]);
+    assert.equal(prepared.artifact.status, 'needs_semantic_review');
+    const inspectedResponse = await callMcp([{ name: 'hyv_lifecycle_inspect', arguments: { artifact_json: JSON.stringify(prepared.artifact) } }]);
+    const inspected = toolPayload(inspectedResponse[0]);
+    assert.equal(inspected.artifactFingerprint, prepared.artifact.artifactFingerprint);
+    assert.doesNotMatch(JSON.stringify(inspected), /sourceHash|candidateHash|payload|signature|nonce/);
+});
+test('runs signed lifecycle and approved-learning replay through registered stdio tools', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'holdyourvoice-mcp-approved-'));
+    try {
+        const source = 'I leverage the answer with useful detail and clear mechanism.';
+        const candidate = 'I use the answer with useful detail and clear mechanism.';
+        const profile = buildProfile(['I write plainly. I name the work.', 'I keep the mechanism clear. I avoid filler.'], ['leverage']);
+        const profileJson = JSON.stringify(profile);
+        const rewriteTask = prepareRewriteForMcp(source, profileJson);
+        const evaluation = applyRewriteForMcp(JSON.stringify(rewriteTask), JSON.stringify({ version: '1', taskFingerprint: rewriteTask.fingerprint, replacements: [{ sentenceId: 1, text: candidate }] }), profileJson);
+        assert.equal(evaluation.status, 'needs_semantic_review');
+        const prepared = prepareLifecycleForMcp(JSON.stringify(evaluation.deterministicArtifact), JSON.stringify(evaluation.lifecycleBinding), JSON.stringify(evaluation.receipt), 'normal', []);
+        const { publicKey, privateKey } = generateKeyPairSync('ed25519');
+        const now = Math.floor(Date.now() / 1000);
+        const trustStore = { version: '1', audience: '@holdyourvoice/hyv', maxCapabilityLifetimeSeconds: 300, keys: [{ issuer: 'test-host', keyId: 'test-key', publicKeySpki: publicKey.export({ type: 'spki', format: 'der' }).toString('base64url'), status: 'active' }] };
+        const context = { now: 0, trustStore, authorizedSemanticEvaluatorIds: { normal: ['test-reviewer'], highAssurance: [] }, authorizedHumanFinalizerIds: ['test-human'] };
+        const env = { ...installedContextEnvironment(root, context), HYV_HOME: join(root, 'state'), HYV_MCP_SENSITIVE_INPUT_REDACTION: '1' };
+        const submittedResponse = await callMcp([{ name: 'hyv_lifecycle_submit_verdict', arguments: { artifact_json: JSON.stringify(prepared.artifact), task_json: JSON.stringify(prepared.task), evaluator_id: 'test-reviewer', verdict_json: JSON.stringify({ approved: true, violations: [] }) } }], env);
+        const ready = toolPayload(submittedResponse[0]);
+        assert.equal(ready.status, 'ready_for_human_review');
+        const rejectedResponse = await callMcp([{ name: 'hyv_lifecycle_finalize', arguments: { artifact_json: JSON.stringify(ready), decision_json: JSON.stringify({ evaluatorId: 'test-human', decision: 'reject' }) } }], { ...env, HYV_MCP_SENSITIVE_INPUT_REDACTION: '' });
+        const rejected = toolPayload(rejectedResponse[0]);
+        assert.equal(rejected.status, 'needs_escalation');
+        assert.equal(rejected.reason, 'human_rejection');
+        const binding = ready.binding;
+        const claims = { version: '1', purpose: 'hyv.final-approval', issuer: 'test-host', audience: '@holdyourvoice/hyv', subjectArtifactFingerprint: ready.artifactFingerprint, sourceHash: binding.sourceHash, candidateHash: binding.candidateHash, profileId: binding.profileId, profileRevisionDigest: binding.profileRevisionDigest, keyId: 'test-key', issuedAt: now - 1, notBefore: now - 1, expiresAt: now + 120, nonce: 'registered-secret-nonce' };
+        const payload = Buffer.from(canonicalJson(claims));
+        const capability = canonicalJson({ payload: payload.toString('base64url'), signature: sign(null, payload, privateKey).toString('base64url') });
+        const decision = JSON.stringify({ evaluatorId: 'test-human', decision: 'approve' });
+        const approvalResponses = await callMcp([
+            { name: 'hyv_lifecycle_validate_final_approval', arguments: { artifact_json: JSON.stringify(ready), capability_json: capability } },
+            { name: 'hyv_lifecycle_finalize', arguments: { artifact_json: JSON.stringify(ready), decision_json: decision, capability_json: capability } },
+        ], env);
+        assert.equal(toolPayload(approvalResponses[0]).ok, true);
+        const approved = toolPayload(approvalResponses[1]);
+        assert.equal(approved.status, 'approved');
+        const learningArguments = { ready_json: JSON.stringify(ready), approved_json: JSON.stringify(approved), original: source, candidate, profile_json: profileJson, decision_json: decision, capability_json: capability };
+        const learned = await callMcp([
+            { name: 'hyv_learning_record_approved', arguments: learningArguments },
+            { name: 'hyv_learning_record_approved', arguments: learningArguments },
+        ], env);
+        assert.equal(toolPayload(learned[0]).status, 'recorded');
+        assert.equal(toolPayload(learned[1]).status, 'nothing_to_learn');
+        const serialized = JSON.stringify({ submittedResponse, rejectedResponse, approvalResponses, learned });
+        assert.doesNotMatch(serialized, /registered-secret-nonce|payload|signature|I leverage|I use/);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('runs the registered MCP learning lifecycle and rejects invalid profile versions', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'holdyourvoice-mcp-lifecycle-'));
+    try {
+        const env = { ...process.env, HYV_HOME: root };
+        const v2Json = JSON.stringify(buildProfile(['I write plainly. I name the work.', 'I keep the mechanism clear. I avoid filler.'], ['leverage']));
+        const v3Json = profileV3Json();
+        const first = await callMcp([
+            { name: 'hyv_learning_record', arguments: { profile_json: v3Json, instruction: 'Keep the mechanism concrete.', mutation_id: 'm1', authority: 'founder', provenance: 'review', weight: 2, compatibility: 'exact' } },
+            { name: 'hyv_learning_inspect', arguments: { profile_json: v3Json } },
+            { name: 'hyv_learning_record', arguments: { profile_json: v2Json, instruction: 'Keep the evidence named.', mutation_id: 'legacy-1' } },
+            { name: 'hyv_learning_migrate', arguments: { source_profile_json: v2Json, target_profile_json: v3Json, mutation_id: 'migration-1' } },
+            { name: 'hyv_learning_ratify', arguments: { profile_json: v2Json, event_id: 'invalid' } },
+            { name: 'hyv_learning_migrate', arguments: { source_profile_json: v3Json, target_profile_json: v2Json } },
+            { name: 'hyv_learning_record', arguments: { profile_json: v3Json, instruction: 'Invalid schema.', mutation_id: 'm'.repeat(201) } },
+        ], env);
+        const recorded = toolPayload(first[0]);
+        assert.equal(recorded.status, 'recorded');
+        assert.equal(toolPayload(first[1])[0].eventType, 'instruction');
+        assert.equal(toolPayload(first[2]).status, 'recorded');
+        assert.equal(toolPayload(first[3]).status, 'recorded');
+        assert.equal(first[4]?.result?.isError, true);
+        assert.equal(first[5]?.result?.isError, true);
+        assert.equal(first[6]?.result?.isError, true);
+        const second = await callMcp([
+            { name: 'hyv_learning_record', arguments: { profile_json: v3Json, instruction: 'Different instruction.', mutation_id: 'm1' } },
+            { name: 'hyv_learning_ratify', arguments: { profile_json: v3Json, event_id: recorded.eventId, mutation_id: 'm2', authority: 'founder' } },
+            { name: 'hyv_learning_supersede', arguments: { profile_json: v3Json, event_id: recorded.eventId, mutation_id: 'm3', authority: 'founder' } },
+            { name: 'hyv_learning_clear', arguments: { profile_json: v3Json } },
+            { name: 'hyv_learning_inspect', arguments: { profile_json: v3Json } },
+        ], env);
+        assert.equal(toolPayload(second[0]).status, 'conflict');
+        assert.equal(toolPayload(second[1]).status, 'recorded');
+        assert.equal(toolPayload(second[2]).status, 'recorded');
+        assert.equal(toolPayload(second[3]).cleared, true);
+        assert.deepEqual(toolPayload(second[4]), []);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
 });
 test('accepts empty text for profile-free hygiene inspection', async () => {
     const server = spawn(process.execPath, [new URL('./cli.js', import.meta.url).pathname, 'mcp'], { stdio: ['pipe', 'pipe', 'pipe'] });
@@ -60,7 +262,7 @@ test('gates exact final output through the registered profile-free MCP tool', as
     assert.equal(rejected.accepted, false);
     assert.equal('output' in rejected, false);
 });
-test('uses default local learning through the registered MCP tools', async () => {
+test('keeps registered MCP verification read-only', async () => {
     const root = mkdtempSync(join(tmpdir(), 'holdyourvoice-mcp-server-'));
     try {
         const profile = buildProfile(['I write plainly. I name the work.', 'I keep the mechanism clear. I avoid filler.'], ['leverage']);
@@ -90,16 +292,13 @@ test('uses default local learning through the registered MCP tools', async () =>
         const batch = JSON.parse(responses.find((response) => response.id === 5)?.result?.content?.[0]?.text ?? '{}');
         const malformed = responses.find((response) => response.id === 6)?.result;
         const hygiene = JSON.parse(responses.find((response) => response.id === 7)?.result?.content?.[0]?.text ?? '{}');
-        assert.match(prompt, /Learned local preferences/);
+        assert.doesNotMatch(prompt, /Learned local preferences/);
         assert.equal(contextual.editorial.findings[0].id, 'editorial.social.generic-opener');
         assert.equal(contextual.hygiene.suspiciousCount, 1);
         assert.deepEqual(batch.findings.map((finding) => finding.id), ['batch.repeated-opening', 'batch.repeated-ending']);
         assert.equal(malformed?.isError, true);
         assert.equal(hygiene.suspiciousCount, 1);
-        const stored = readFileSync(join(root, 'learning', `${profileFingerprint(profile)}.jsonl`), 'utf8');
-        assert.match(stored, /ai\.leverage/);
-        assert.doesNotMatch(stored, /I leverage the answer/);
-        assert.doesNotMatch(stored, /I use the answer/);
+        assert.equal(existsSync(join(root, 'learning', `${profileFingerprint(profile)}.jsonl`)), false);
     }
     finally {
         rmSync(root, { recursive: true, force: true });

package/dist/pipeline.js

@@ -1,12 +1,15 @@
+import { createHash } from 'node:crypto';
+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 { inspectHygiene } from './hygiene.js';
+import { finalOutputCheck, inspectHygiene } from './hygiene.js';
 import { analyzeVoiceDna } from './voice-dna.js';
-import { words } from './text.js';
+import { legacySetPreservation } from './preservation.js';
 export function analyze(text, profile, brief) {
     const voiceDna = analyzeVoiceDna(text, profile);
-    const aiEditor = analyzeAiEditor(text);
+    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) };
@@ -20,11 +23,24 @@ function formatBriefValue(value) {
 function formatFindings(findings) {
     return findings.map((finding) => `- Sentence ${finding.sentence} [${finding.engine}/${finding.id}]: ${formatBriefValue(finding.reason)} Repair: ${formatBriefValue(finding.suggestion)}`);
 }
-export function rewritePrompt(draft, profile, learning = [], brief) {
-    const result = analyze(draft, profile, brief);
+export function isBlockingFinding(finding) {
+    return finding.engine === 'ai_editor' ? finding.appliedPolicy === 'blocking' : finding.severity === 'red';
+}
+export function deriveEditScope(result) {
+    const findings = [...result.voiceDna.findings, ...result.aiEditor.findings, ...(result.editorial?.findings ?? [])];
+    const blocking = findings.filter(isBlockingFinding);
+    const pendingJudgment = 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) {
     const allFindings = [...result.voiceDna.findings, ...result.aiEditor.findings, ...(result.editorial?.findings ?? [])];
-    const redFindings = allFindings.filter((finding) => finding.severity === 'red');
-    const yellowFindings = allFindings.filter((finding) => finding.severity === 'yellow');
+    const scope = deriveEditScope(result);
+    const redFindings = scope.blocking;
+    const yellowFindings = allFindings.filter((finding) => !isBlockingFinding(finding) && finding.appliedPolicy !== 'judgment-required');
     const metrics = profile.metrics;
     return [
         '# Tier 0 — non-negotiable preservation',
@@ -46,6 +62,9 @@ export function rewritePrompt(draft, profile, learning = [], brief) {
         '',
         '# Tier 3 — AI Editor improvements',
         ...(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.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',
@@ -55,26 +74,28 @@ export function rewritePrompt(draft, profile, learning = [], brief) {
         draft,
     ].join('\n');
 }
-function preservationScore(original, candidate) {
-    const baseline = new Set(words(original.toLowerCase()).filter((word) => word.length > 4));
-    const rewritten = new Set(words(candidate.toLowerCase()));
-    return baseline.size ? Math.round([...baseline].filter((word) => rewritten.has(word)).length / baseline.size * 100) : 100;
+export function rewritePrompt(draft, profile, learning = [], brief) {
+    return renderRewritePrompt(draft, profile, analyze(draft, profile, brief), learning, brief);
 }
-export function verify(original, candidate, profile, brief) {
+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 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 = preservationScore(original, candidate);
+    const preservation = legacySetPreservation(original, candidate).score;
+    return { baseline, checked, regressions, preservation };
+}
+export function verify(original, candidate, profile, brief) {
+    const { baseline, checked, regressions, preservation } = compareCandidates(original, candidate, profile, brief);
     return {
         version: '2',
         original: baseline,
         candidate: checked,
         preservationScore: preservation,
         regressions,
-        passed: checked.passed && !regressions.some((finding) => finding.severity === 'red') && preservation >= 70,
+        passed: checked.passed && !regressions.some(isBlockingFinding) && preservation >= 70,
     };
 }
 export function verifyWithCopySpec(original, candidate, profile, spec, brief) {
@@ -82,3 +103,46 @@ export function verifyWithCopySpec(original, candidate, profile, spec, 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 hygiene = inspectHygiene(candidate);
+    const finalCheck = finalOutputCheck(candidate);
+    return {
+        version: '2',
+        original: baseline,
+        candidate: checked,
+        preservationScore: preservation,
+        regressions,
+        claims,
+        passed: checked.passed && !regressions.some(isBlockingFinding) && claims.passed && hygiene.suspiciousCount === 0 && finalCheck.accepted,
+    };
+}
+function digest(value) { return createHash('sha256').update(value).digest('hex'); }
+function digestCanonical(value) { return digest(canonicalJson(value)); }
+function profileIdentity(profile) {
+    if (profile.version === '3')
+        return { profileId: profile.id, profileRevisionDigest: profile.revisionDigest };
+    const legacy = `legacy-v2:${digestCanonical(profile)}`;
+    return { profileId: legacy, profileRevisionDigest: legacy };
+}
+function projectDeterministicVerificationArtifact(source, candidate, profile, verification, copySpec, writingBrief, verificationKind = 'claims' in verification ? 'copy_spec' : 'standard') {
+    const identity = profileIdentity(profile);
+    const base = {
+        version: '1', verificationKind, passed: verification.passed, analysisVersion: verification.candidate.version,
+        rulesetVersion: HYV_VERSION, preservationMetricVersion: 'legacy-set-v1', preservationScore: verification.preservationScore,
+        sourceHash: digest(source), candidateHash: digest(candidate), ...identity,
+        ...(copySpec ? { copySpecHash: digestCanonical(copySpec) } : {}), ...(writingBrief ? { writingBriefHash: digestCanonical(writingBrief) } : {}),
+        regressionKeys: verification.regressions.map((finding) => `${finding.engine}:${finding.id}:${finding.sentence}`).sort(),
+        ...('claims' in verification ? { claimFailureKeys: verification.claims.failures.map((failure) => `${failure.id}:${failure.code}`).sort() } : {}),
+    };
+    return { ...base, artifactFingerprint: digest(`hyv:deterministic-verification:v1\0${canonicalJson(base)}`) };
+}
+export function verifyDeterministically(source, candidate, profile, copySpec, writingBrief) {
+    const verification = copySpec ? verifyWithCopySpec(source, candidate, profile, copySpec, writingBrief) : verify(source, candidate, profile, writingBrief);
+    return { verification, artifact: projectDeterministicVerificationArtifact(source, candidate, profile, verification, copySpec, writingBrief) };
+}
+export function verifyRebuildDeterministically(source, candidate, profile, copySpec, writingBrief) {
+    const verification = verifyRebuildWithCopySpec(source, candidate, profile, copySpec, writingBrief);
+    return { verification, artifact: projectDeterministicVerificationArtifact(source, candidate, profile, verification, copySpec, writingBrief, 'rebuild') };
+}

package/dist/pipeline.test.js

@@ -1,16 +1,18 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { analyze, rewritePrompt, verify, verifyWithCopySpec } from './pipeline.js';
+import { analyze, rewritePrompt, verify, verifyDeterministically, verifyWithCopySpec } from './pipeline.js';
 import { parseCopySpec } from './copy-spec.js';
 import { parseWritingBrief } from './editorial-packs.js';
 import { buildProfile } from './voice-dna.js';
+import { comparePreservation } from './preservation.js';
 const profile = buildProfile([
     'I ship clear ideas. The details stay concrete. I explain the mechanism without fuss.',
     'I write short sentences. Then I explain the mechanism. My work stays plain and specific.',
 ], ['leverage']);
 test('keeps the two engine scores independent', () => {
     const result = analyze('Firstly, we leverage a holistic strategy.', profile);
-    assert.equal(result.aiEditor.passed, false);
+    assert.equal(result.aiEditor.passed, true);
+    assert.equal(result.voiceDna.passed, false);
     assert.equal(typeof result.voiceDna.score, 'number');
 });
 test('reports hidden Unicode without changing either engine or the release decision', () => {
@@ -47,6 +49,28 @@ test('post gate reports a new AI regression', () => {
     assert.equal(result.original.aiEditor.passed, true);
     assert.equal(result.candidate.aiEditor.passed, false);
 });
+test('advisory and pending-judgment findings pass while blocking findings fail', () => {
+    const advisory = analyze('Firstly, check the invoice.', profile);
+    assert.equal(advisory.passed, true);
+    const neutralProfile = buildProfile(['I write plainly.', 'I name the mechanism.']);
+    const pending = analyze('We leverage the scheduler.', neutralProfile);
+    assert.equal(pending.passed, true);
+    const blocking = analyze('The scheduler failed — twice.', profile);
+    assert.equal(blocking.passed, false);
+});
+test('verify rejects only new policy-blocking regressions', () => {
+    const neutralProfile = buildProfile(['I write plainly.', 'I name the mechanism.']);
+    assert.equal(verify('The scheduler failed twice.', 'The scheduler failed twice. We leverage logs.', neutralProfile).passed, true);
+    assert.equal(verify('The scheduler failed twice.', 'The scheduler failed — twice.', profile).passed, false);
+});
+test('keeps verify pass/fail on the legacy metric while calibration reports both metrics', () => {
+    const original = 'alpha bravo alpha charlie durable signal';
+    const candidate = 'alpha charlie bravo durable signal';
+    const verification = verify(original, candidate, profile);
+    const calibration = comparePreservation(original, candidate);
+    assert.equal(verification.preservationScore, calibration.legacySet.score);
+    assert.notEqual(calibration.legacySet.score / 100, calibration.orderedToken.wordSurvival);
+});
 test('puts all thirteen VoiceDNA elements in the rewrite brief', () => {
     const prompt = rewritePrompt('I ship clear ideas.', profile);
     for (const element of ['Sentence length', 'sentence variation', 'sentence structure', 'rhythm', 'Paragraph length', 'lexical density', 'point of view', 'punctuation', 'case style', 'question rate', 'Openings', 'Vocabulary', 'Transitions']) {
@@ -136,3 +160,13 @@ test('requires usable CopySpec atoms', () => {
     const substring = verifyWithCopySpec('मॉडल INT4 उपलब्ध है।', 'यह नयामॉडल INT4 है।', profile, unicode);
     assert.deepEqual(substring.claims.failures.map((failure) => failure.code), ['missing_immutable_atom']);
 });
+test('projects a stable text-free deterministic verification artifact', () => {
+    const original = 'I write clear notes.';
+    const candidate = 'I write clear notes.';
+    const left = verifyDeterministically(original, candidate, profile).artifact;
+    const right = verifyDeterministically(original, candidate, profile).artifact;
+    assert.deepEqual(left, right);
+    assert.equal(left.passed, true);
+    assert.doesNotMatch(JSON.stringify(left), /I write clear notes/);
+    assert.notEqual(verifyDeterministically(original, `${candidate} Changed.`, profile).artifact.artifactFingerprint, left.artifactFingerprint);
+});

package/dist/preservation.js

@@ -0,0 +1,89 @@
+import { words } from './text.js';
+export const LEGACY_SET_PRESERVATION_VERSION = 'legacy-set-v1';
+export const ORDERED_TOKEN_PRESERVATION_VERSION = 'ordered-token-sequence-v1';
+function donorTokens(text) {
+    return (text.match(/[A-Za-z0-9$%#][A-Za-z0-9$%#'’.,-]*/g) ?? [])
+        .map((token) => token.replace(/^[.,'’]+|[.,'’]+$/g, '').toLowerCase());
+}
+function lowerBound(values, target) {
+    let low = 0;
+    let high = values.length;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (values[middle] < target)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}
+function tokenPositions(tokens) {
+    const positions = new Map();
+    tokens.forEach((token, index) => {
+        const indexes = positions.get(token) ?? [];
+        indexes.push(index);
+        positions.set(token, indexes);
+    });
+    return positions;
+}
+function longestMatch(left, rightPositions, leftStart, leftEnd, rightStart, rightEnd) {
+    let best = [leftStart, rightStart, 0];
+    let previous = new Map();
+    for (let leftIndex = leftStart; leftIndex < leftEnd; leftIndex += 1) {
+        const current = new Map();
+        const indexes = rightPositions.get(left[leftIndex]) ?? [];
+        for (let position = lowerBound(indexes, rightStart); position < indexes.length && indexes[position] < rightEnd; position += 1) {
+            const rightIndex = indexes[position];
+            const size = (previous.get(rightIndex - 1) ?? 0) + 1;
+            current.set(rightIndex, size);
+            const start = [leftIndex - size + 1, rightIndex - size + 1, size];
+            if (size > best[2] || (size === best[2] && (start[0] < best[0] || (start[0] === best[0] && start[1] < best[1]))))
+                best = start;
+        }
+        previous = current;
+    }
+    return best;
+}
+function matchedOrderedTokens(left, right) {
+    const rightPositions = tokenPositions(right);
+    const pending = [[0, left.length, 0, right.length]];
+    let matched = 0;
+    while (pending.length) {
+        const [leftStart, leftEnd, rightStart, rightEnd] = pending.pop();
+        const [matchLeft, matchRight, size] = longestMatch(left, rightPositions, leftStart, leftEnd, rightStart, rightEnd);
+        if (!size)
+            continue;
+        matched += size;
+        if (leftStart < matchLeft && rightStart < matchRight)
+            pending.push([leftStart, matchLeft, rightStart, matchRight]);
+        if (matchLeft + size < leftEnd && matchRight + size < rightEnd)
+            pending.push([matchLeft + size, leftEnd, matchRight + size, rightEnd]);
+    }
+    return matched;
+}
+function roundThree(value) {
+    const scaled = value * 1000;
+    const lower = Math.floor(scaled);
+    const fraction = scaled - lower;
+    if (Math.abs(fraction - 0.5) < Number.EPSILON * Math.max(1, Math.abs(scaled)) * 2)
+        return (lower + (lower % 2)) / 1000;
+    return Math.round(scaled) / 1000;
+}
+export function legacySetPreservation(original, candidate) {
+    const baseline = new Set(words(original.toLowerCase()).filter((word) => word.length > 4));
+    const rewritten = new Set(words(candidate.toLowerCase()));
+    const score = baseline.size ? Math.round([...baseline].filter((word) => rewritten.has(word)).length / baseline.size * 100) : 100;
+    return { version: LEGACY_SET_PRESERVATION_VERSION, score };
+}
+export function orderedTokenPreservation(original, candidate) {
+    const baseline = donorTokens(original);
+    const rewritten = donorTokens(candidate);
+    return {
+        version: ORDERED_TOKEN_PRESERVATION_VERSION,
+        wordSurvival: roundThree(matchedOrderedTokens(baseline, rewritten) / Math.max(baseline.length, 1)),
+        lengthRatio: roundThree(rewritten.length / Math.max(baseline.length, 1)),
+    };
+}
+export function comparePreservation(original, candidate) {
+    return { legacySet: legacySetPreservation(original, candidate), orderedToken: orderedTokenPreservation(original, candidate) };
+}

package/dist/preservation.test.js

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { comparePreservation, legacySetPreservation, orderedTokenPreservation } from './preservation.js';
+test('reports separately versioned legacy and ordered-token preservation values', () => {
+    const report = comparePreservation('alpha bravo alpha charlie', 'alpha charlie bravo');
+    assert.deepEqual(report, {
+        legacySet: { version: 'legacy-set-v1', score: 100 },
+        orderedToken: { version: 'ordered-token-sequence-v1', wordSurvival: 0.5, lengthRatio: 0.75 },
+    });
+});
+test('ports donor token normalization and ordered matching without changing the legacy arithmetic', () => {
+    assert.equal(orderedTokenPreservation("Ship, DON'T stop.", "don't ship stop").wordSurvival, 0.667);
+    assert.equal(legacySetPreservation('tiny plus durable signal', 'durable signal').score, 100);
+});
+test('defines empty-input denominators explicitly', () => {
+    assert.deepEqual(orderedTokenPreservation('', ''), { version: 'ordered-token-sequence-v1', wordSurvival: 0, lengthRatio: 0 });
+    assert.deepEqual(legacySetPreservation('', 'new text'), { version: 'legacy-set-v1', score: 100 });
+});
+test('matches the donor metric three-decimal half-even rounding', () => {
+    const original = Array.from({ length: 16 }, (_, index) => `token${index}`).join(' ');
+    assert.equal(orderedTokenPreservation(original, 'token0').wordSurvival, 0.062);
+});