@holdyourvoice/hyv 3.6.0 → 4.0.0

package/dist/rewrite-task.test.js

@@ -1,166 +0,0 @@
-import assert from 'node:assert/strict';
-import { createHash } from 'node:crypto';
-import test from 'node:test';
-import { applyRewriteResponse, createRewriteLifecycleBinding, evaluateRewriteResponse, parseRewriteTask, prepareRewriteTask } from './rewrite-task.js';
-import { parseWritingBrief } from './editorial-packs.js';
-import { canonicalJson } from './canonical-json.js';
-import { verifyDeterministically } from './pipeline.js';
-import { buildProfile } from './voice-dna.js';
-const profile = buildProfile([
-    'I write clear notes. I keep the mechanism visible.',
-    'I name the trade-off. Then I make the next step plain.',
-], ['leverage']);
-test('applies only eligible numbered replacements and preserves all clean bytes', () => {
-    const task = prepareRewriteTask('I leverage the answer. The launch is on 14 August.', profile);
-    const result = applyRewriteResponse(task, {
-        version: '1',
-        taskFingerprint: task.fingerprint,
-        replacements: [{ sentenceId: 1, text: 'I use the answer.' }],
-    });
-    assert.equal(result.status, 'accepted');
-    assert.equal(result.candidate, 'I use the answer. The launch is on 14 August.');
-    assert.deepEqual(result.receipt.adapterIds, []);
-});
-test('makes every active AI Editor finding eligible under the default strict rewrite policy', () => {
-    const task = prepareRewriteTask('I write clear notes. This work is meaningful. I keep the mechanism visible.', profile);
-    assert.deepEqual(task.eligibleSentenceIds, [2]);
-    assert.deepEqual(task.sentences.map((sentence) => sentence.eligible), [false, true, false]);
-    assert.match(task.prompt, /Every active AI Editor finding is a required repair/);
-});
-test('makes advisory and judgment-required findings required repairs', () => {
-    const advisory = prepareRewriteTask('Firstly, check the invoice.', profile);
-    assert.deepEqual(advisory.eligibleSentenceIds, [1]);
-    const neutralProfile = buildProfile(['I write plainly.', 'I name the mechanism.']);
-    const pending = prepareRewriteTask('We leverage the scheduler.', neutralProfile);
-    assert.deepEqual(pending.eligibleSentenceIds, [1]);
-    assert.match(pending.prompt, /Every active AI Editor finding is a required repair/);
-    const blocking = prepareRewriteTask('The scheduler failed — twice. The owner checked it.', profile);
-    assert.deepEqual(blocking.eligibleSentenceIds, [1]);
-});
-test('keeps blocking VoiceDNA avoid findings eligible', () => {
-    const task = prepareRewriteTask('The plan uses leverage.', profile);
-    assert.deepEqual(task.eligibleSentenceIds, [1]);
-});
-test('makes reconciled active founder reframes eligible under the default strict policy', () => {
-    const task = prepareRewriteTask("This isn't positioning. This is proof.", profile);
-    assert.deepEqual(task.eligibleSentenceIds, [1]);
-});
-test('preserves a clean draft byte-for-byte when the rewrite response is empty', () => {
-    const draft = 'I write clear notes.\n\nI keep the mechanism visible.\n';
-    const task = prepareRewriteTask(draft, profile);
-    assert.deepEqual(task.eligibleSentenceIds, []);
-    const result = applyRewriteResponse(task, { version: '1', taskFingerprint: task.fingerprint, replacements: [] });
-    assert.equal(result.status, 'accepted');
-    assert.equal(result.candidate, draft);
-});
-test('rejects an attempted edit to a clean sentence without changing any source bytes', () => {
-    const draft = 'I leverage the answer.\n\nThe launch starts Tuesday.\n';
-    const task = prepareRewriteTask(draft, profile);
-    const result = applyRewriteResponse(task, { version: '1', taskFingerprint: task.fingerprint, replacements: [{ sentenceId: 2, text: 'The launch starts Wednesday.' }] });
-    assert.equal(result.status, 'repairable');
-    assert.equal(result.candidate, undefined);
-    assert.equal(result.failures[0]?.code, 'ineligible_sentence_id');
-    assert.equal(task.draft, draft);
-});
-test('carries WritingBrief context into a fingerprinted rewrite task', () => {
-    const brief = parseWritingBrief({ version: '1', audience: 'founders', intent: 'start a discussion', format: 'social' });
-    const task = prepareRewriteTask('A pattern I keep seeing in founder posts is vague advice.', profile, undefined, brief);
-    assert.equal(task.writingBrief?.format, 'social');
-    assert.deepEqual(task.eligibleSentenceIds, []);
-});
-test('rejects a fingerprint-valid rewrite task with malformed WritingBrief data', () => {
-    const task = prepareRewriteTask('I leverage the answer.', profile);
-    const { fingerprint: _fingerprint, ...taskBase } = task;
-    const base = { ...taskBase, writingBrief: { version: '1', audience: 'operators', intent: 'write', format: 'general', prohibitedTerms: [42] } };
-    const malformed = { ...base, fingerprint: createHash('sha256').update(canonicalJson(base)).digest('hex') };
-    assert.throws(() => parseRewriteTask(malformed), /WritingBrief/);
-});
-test('rejects a fingerprint-valid rewrite task with a null WritingBrief', () => {
-    const task = prepareRewriteTask('I leverage the answer.', profile);
-    const { fingerprint: _fingerprint, ...taskBase } = task;
-    const base = { ...taskBase, writingBrief: null };
-    const malformed = { ...base, fingerprint: createHash('sha256').update(canonicalJson(base)).digest('hex') };
-    assert.throws(() => parseRewriteTask(malformed), /WritingBrief/);
-});
-test('rejects a duplicate, unknown, or clean sentence replacement before it creates a candidate', () => {
-    const task = prepareRewriteTask('I leverage the answer. The launch is on 14 August.', profile);
-    const duplicate = applyRewriteResponse(task, JSON.stringify({
-        version: '1', taskFingerprint: task.fingerprint,
-        replacements: [{ sentenceId: 1, text: 'I use the answer.' }, { sentenceId: 1, text: 'I choose the answer.' }],
-    }));
-    assert.equal(duplicate.status, 'repairable');
-    assert.equal(duplicate.candidate, undefined);
-    assert.equal(duplicate.failures[0]?.code, 'duplicate_sentence_id');
-    const unknown = applyRewriteResponse(task, {
-        version: '1', taskFingerprint: task.fingerprint,
-        replacements: [{ sentenceId: 99, text: 'I use the answer.' }],
-    });
-    assert.equal(unknown.status, 'repairable');
-    assert.equal(unknown.failures[0]?.code, 'unknown_sentence_id');
-});
-test('repairs only a stringified replacement list after initial schema rejection', () => {
-    const task = prepareRewriteTask('I leverage the answer.', profile);
-    const result = applyRewriteResponse(task, JSON.stringify({
-        version: '1', taskFingerprint: task.fingerprint,
-        replacements: JSON.stringify([{ sentenceId: 1, text: 'I use the answer.' }]),
-    }));
-    assert.equal(result.status, 'accepted');
-    assert.equal(result.candidate, 'I use the answer.');
-    assert.deepEqual(result.receipt.adapterIds, ['stringified_replacements_v1']);
-});
-test('keeps a valid response byte-for-byte unchanged by repair adapters', () => {
-    const task = prepareRewriteTask('I leverage the answer.', profile);
-    const response = JSON.stringify({ version: '1', taskFingerprint: task.fingerprint, replacements: [{ sentenceId: 1, text: 'I use the answer.' }] });
-    const result = applyRewriteResponse(task, response);
-    assert.equal(result.status, 'accepted');
-    assert.equal(result.receipt.responseFingerprint.length, 64);
-    assert.deepEqual(result.receipt.adapterIds, []);
-    assert.deepEqual(result.receipt.replacementSentenceIds, [1]);
-});
-test('withholds an unresolved final-output candidate from evaluation results', () => {
-    const task = prepareRewriteTask('I leverage the answer.', profile);
-    const result = evaluateRewriteResponse(task, { version: '1', taskFingerprint: task.fingerprint, replacements: [{ sentenceId: 1, text: 'I use the answer.\u200B' }] }, profile);
-    assert.equal(result.status, 'needs_escalation');
-    assert.equal(result.candidate, undefined);
-    assert.equal(result.verification?.finalOutput.accepted, false);
-});
-test('returns the final-gate-cleaned candidate and hashes that value', () => {
-    const task = prepareRewriteTask('I leverage the answer with useful detail and clear mechanism.', profile);
-    const result = evaluateRewriteResponse(task, { version: '1', taskFingerprint: task.fingerprint, replacements: [{ sentenceId: 1, text: 'I use the\u0007 answer with useful detail and clear mechanism.' }] }, profile);
-    assert.equal(result.status, 'needs_semantic_review');
-    assert.equal(result.candidate, 'I use the answer with useful detail and clear mechanism.');
-    assert.equal(result.verification?.finalOutput.changed, true);
-    assert.equal(result.deterministicArtifact?.candidateHash, createHash('sha256').update('I use the answer with useful detail and clear mechanism.').digest('hex'));
-});
-test('binds the task, response, deterministic artifact, text hashes, and profile revision', () => {
-    const draft = 'I write clear notes.';
-    const task = prepareRewriteTask(draft, profile);
-    const applied = applyRewriteResponse(task, { version: '1', taskFingerprint: task.fingerprint, replacements: [] });
-    assert.equal(applied.status, 'accepted');
-    const artifact = verifyDeterministically(draft, applied.candidate, profile).artifact;
-    const binding = createRewriteLifecycleBinding(task, applied.receipt, artifact);
-    assert.equal(binding.rewriteTaskFingerprint, task.fingerprint);
-    assert.equal(binding.rewriteResponseFingerprint, applied.receipt.responseFingerprint);
-    assert.equal(binding.deterministicArtifactFingerprint, artifact.artifactFingerprint);
-    assert.match(binding.sourceHash, /^[a-f0-9]{64}$/);
-});
-test('returns the deterministic artifact and lifecycle binding at the semantic gate', () => {
-    const task = prepareRewriteTask('I write clear notes.', profile);
-    const result = evaluateRewriteResponse(task, { version: '1', taskFingerprint: task.fingerprint, replacements: [] }, profile);
-    assert.equal(result.status, 'needs_semantic_review');
-    assert.equal(result.deterministicArtifact?.passed, true);
-    assert.equal(result.lifecycleBinding?.deterministicArtifactFingerprint, result.deterministicArtifact?.artifactFingerprint);
-});
-test('keeps object response fingerprints stable across property order', () => {
-    const task = prepareRewriteTask('I leverage the answer.', profile);
-    const first = applyRewriteResponse(task, { version: '1', taskFingerprint: task.fingerprint, replacements: [{ sentenceId: 1, text: 'I use the answer.' }] });
-    const second = applyRewriteResponse(task, { replacements: [{ text: 'I use the answer.', sentenceId: 1 }], taskFingerprint: task.fingerprint, version: '1' });
-    assert.equal(first.receipt.responseFingerprint, second.receipt.responseFingerprint);
-});
-test('repairs only an exact outer JSON code fence after JSON parsing fails', () => {
-    const task = prepareRewriteTask('I leverage the answer with useful detail and clear mechanism.', profile);
-    const response = `\`\`\`json\n${JSON.stringify({ version: '1', taskFingerprint: task.fingerprint, replacements: [{ sentenceId: 1, text: 'I use the answer with useful detail and clear mechanism.' }] })}\n\`\`\``;
-    const result = applyRewriteResponse(task, response);
-    assert.equal(result.status, 'accepted');
-    assert.deepEqual(result.receipt.adapterIds, ['fenced_json_v1']);
-});

package/dist/rule-allowances.test.js

@@ -1,17 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { deriveRuleAllowances } from './rule-allowances.js';
-test('derives only non-verbatim style allowances from repeated sample evidence', () => {
-    const allowances = deriveRuleAllowances([
-        'I write this way — with a deliberate turn.',
-        'The point is direct — then I explain it.',
-        'The note says “ship Tuesday” after the check.',
-        'The runbook repeats “ship Tuesday” as a decision.',
-        'A plain sample has no allowance.',
-    ]);
-    assert.deepEqual(Object.keys(allowances), ['punct.em-dash', 'format.curly-quotes']);
-    assert.equal(allowances['punct.em-dash'].sampleCount, 2);
-    assert.match(allowances['punct.em-dash'].evidenceDigest, /^[a-f0-9]{64}$/);
-    assert.equal(allowances['format.curly-quotes'].sampleCount, 2);
-    assert.equal(JSON.stringify(allowances).includes('deliberate turn'), false);
-});

package/dist/rule-reconciliation.test.js

@@ -1,50 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { rules } from './ai-editor-rules.js';
-function rule(id) {
-    const match = rules.find((candidate) => candidate.id === id);
-    assert.ok(match, `missing rule ${id}`);
-    return match;
-}
-test('struct.not-x-y only detects an explicit two-beat contrast', () => {
-    const matcher = rule('struct.not-x-y').expression;
-    assert.equal(matcher.test('Not speed. Reliability.'), true);
-    assert.equal(matcher.test('This does not include the standard onboarding steps every team runs.'), false);
-});
-test('keeps the explicit this-isnt reframe matcher available to policy', () => {
-    const matcher = rule('struct.this-isnt-x-this-is-y').expression;
-    assert.equal(matcher.test("This isn't positioning. This is proof."), true);
-    assert.equal(matcher.test('This positioning claim has proof.'), false);
-});
-test('treats both long dash characters as red findings', () => {
-    const emDash = rule('punct.em-dash');
-    const enDash = rule('punct.en-dash');
-    assert.equal(emDash.severity, 'red');
-    assert.equal(enDash.severity, 'red');
-    assert.equal(emDash.expression.test('The job failed — retry it.'), true);
-    assert.equal(enDash.expression.test('Use pages 6–11.'), true);
-    assert.equal(emDash.expression.test('The job failed; retry it.'), false);
-    assert.equal(enDash.expression.test('Use pages 6-11.'), false);
-});
-test('detects clear performative-sincerity phrases as red', () => {
-    const matcher = rule('formula.performative-sincerity');
-    assert.equal(matcher.severity, 'red');
-    for (const text of ['To be honest, the launch failed.', 'In all honesty, the launch failed.']) {
-        assert.equal(matcher.expression.test(text), true, text);
-    }
-    assert.equal(matcher.expression.test('The honest report says the launch failed.'), false);
-});
-test('detects performative-sincerity adverbs as yellow', () => {
-    const matcher = rule('hedge.performative-sincerity-adverb');
-    assert.equal(matcher.severity, 'yellow');
-    for (const text of [
-        'Honestly, the launch failed.',
-        'Genuinely, the launch failed.',
-        'Truly, the launch failed.',
-        'Frankly, the launch failed.',
-        'Actually, the launch failed.',
-    ]) {
-        assert.equal(matcher.expression.test(text), true, text);
-    }
-    assert.equal(matcher.expression.test('The genuine invoice arrived.'), false);
-});

package/dist/sample-ingest.test.js

@@ -1,52 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { ingestGmailSentMbox, ingestTelegramDesktopJson } from './sample-ingest.js';
-test('ingests only owner Gmail sent messages and redacts sensitive data before output', () => {
-    const mbox = [
-        'From sender@example.com Mon Jan 1 00:00:00 2026',
-        'From: Owner <owner@example.com>',
-        '',
-        'Call +1 415 555 0100 or owner@example.com. Secret client detail stays out.',
-        'From sender@example.com Mon Jan 2 00:00:00 2026',
-        'From: Other <other@example.com>',
-        '',
-        'This message must not become a sample.',
-    ].join('\n');
-    const result = ingestGmailSentMbox(mbox, 'Owner <owner@example.com>', ['secret client']);
-    assert.equal(result.samples.length, 1);
-    assert.match(result.samples[0], /REDACTED:PHONE/);
-    assert.match(result.samples[0], /REDACTED:EMAIL/);
-    assert.equal(result.samples[0].includes('Secret client'), false);
-    assert.equal(result.receipt.droppedSentences, 1);
-    assert.equal(JSON.stringify(result.receipt).includes('Secret client'), false);
-    assert.equal(JSON.stringify(result.receipt).includes('owner@example.com'), false);
-});
-test('ingests Telegram Desktop JSON by explicit owner and never places raw text in the receipt', () => {
-    const source = JSON.stringify({ messages: [
-            { type: 'message', from: 'Shashank', text: ['A link is ', { type: 'link', text: 'https://example.com/private' }, '.'] },
-            { type: 'message', from: 'Other', text: 'Ignore me.' },
-        ] });
-    const result = ingestTelegramDesktopJson(source, 'Shashank');
-    assert.equal(result.samples.length, 1);
-    assert.match(result.samples[0], /REDACTED:URL/);
-    assert.equal(JSON.stringify(result.receipt).includes('Ignore me'), false);
-    assert.equal(JSON.stringify(result.receipt).includes('example.com'), false);
-    assert.equal(result.receipt.presidio, 'NOT_CONFIGURED');
-});
-test('parsing local exports cannot open a socket', async () => {
-    const net = (await import('node:' + 'net')).default;
-    const writable = net;
-    const originalConnect = writable.connect;
-    const originalCreateConnection = writable.createConnection;
-    const denied = () => { throw new Error('network must remain unavailable'); };
-    writable.connect = denied;
-    writable.createConnection = denied;
-    try {
-        const result = ingestTelegramDesktopJson(JSON.stringify({ messages: [{ type: 'message', from: 'Owner', text: 'A local export stays local.' }] }), 'Owner');
-        assert.equal(result.samples.length, 1);
-    }
-    finally {
-        writable.connect = originalConnect;
-        writable.createConnection = originalCreateConnection;
-    }
-});

package/dist/semantic-review.test.js

@@ -1,101 +0,0 @@
-import assert from 'node:assert/strict';
-import { createHash, generateKeyPairSync, sign } from 'node:crypto';
-import test from 'node:test';
-import { canonicalJson, canonicalJsonBytes } from './canonical-json.js';
-import { createInitialLifecycleArtifact, parseSemanticVerdict, prepareSemanticReviewTask, reduceRewriteLifecycle, reviewSemanticVerdicts } from './semantic-review.js';
-const deterministicBase = { 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 deterministicFingerprint = createHash('sha256').update(`hyv:deterministic-verification:v1\0${canonicalJson(deterministicBase)}`).digest('hex');
-const binding = { rewriteTaskFingerprint: '1'.repeat(64), rewriteResponseFingerprint: '2'.repeat(64), deterministicArtifactFingerprint: deterministicFingerprint, sourceHash: deterministicBase.sourceHash, candidateHash: deterministicBase.candidateHash, profileId: deterministicBase.profileId, profileRevisionDigest: deterministicBase.profileRevisionDigest, rulesetVersion: deterministicBase.rulesetVersion, schemaVersion: '1' };
-const receipt = { version: '1', taskFingerprint: binding.rewriteTaskFingerprint, responseFingerprint: binding.rewriteResponseFingerprint, adapterIds: [], replacementSentenceIds: [3, 1] };
-function task(policy = 'normal') { return prepareSemanticReviewTask(binding, policy, receipt, ['action_change']); }
-function deterministic(passed = true) { const base = { ...deterministicBase, passed }; return { ...base, artifactFingerprint: createHash('sha256').update(`hyv:deterministic-verification:v1\0${canonicalJson(base)}`).digest('hex') }; }
-const emptyTrust = { version: '1', audience: '@holdyourvoice/hyv', maxCapabilityLifetimeSeconds: 300, keys: [] };
-const context = { now: 150, trustStore: emptyTrust, authorizedSemanticEvaluatorIds: { normal: ['one'], highAssurance: ['one', 'two', 'three'] }, authorizedHumanFinalizerIds: ['human-1'] };
-test('preserves the version 3.2 semantic aggregation API', () => {
-    const verdicts = ['one', 'two', 'three'].map((id) => parseSemanticVerdict(id, { approved: true, violations: [] }));
-    assert.equal(reviewSemanticVerdicts(verdicts).status, 'accepted');
-});
-test('normal review clears with one clean authorized verdict and rejection escalates', () => {
-    const reviewTask = task();
-    const initial = createInitialLifecycleArtifact(reviewTask, deterministic());
-    const clean = parseSemanticVerdict(reviewTask, 'one', { approved: true, violations: [] });
-    const cleared = reduceRewriteLifecycle(initial, { version: '1', type: 'semantic_submission', parentArtifactFingerprint: initial.artifactFingerprint, taskFingerprint: reviewTask.taskFingerprint, verdicts: [clean] }, context);
-    assert.equal(cleared.ok && cleared.artifact.status, 'ready_for_human_review');
-    const rejected = parseSemanticVerdict(reviewTask, 'one', { approved: false, violations: ['action_change'] });
-    const escalated = reduceRewriteLifecycle(initial, { version: '1', type: 'semantic_submission', parentArtifactFingerprint: initial.artifactFingerprint, taskFingerprint: reviewTask.taskFingerprint, verdicts: [rejected] }, context);
-    assert.equal(escalated.ok && escalated.artifact.status, 'needs_escalation');
-});
-test('high assurance is permutation-stable and requires three configured evaluators', () => {
-    const reviewTask = task('high_assurance');
-    const initial = createInitialLifecycleArtifact(reviewTask, deterministic());
-    const verdicts = ['three', 'one', 'two'].map((id) => parseSemanticVerdict(reviewTask, id, { approved: true, violations: [] }));
-    const action = { version: '1', type: 'semantic_submission', parentArtifactFingerprint: initial.artifactFingerprint, taskFingerprint: reviewTask.taskFingerprint, verdicts };
-    const left = reduceRewriteLifecycle(initial, action, context);
-    const right = reduceRewriteLifecycle(initial, { ...action, verdicts: [...verdicts].reverse() }, context);
-    assert.deepEqual(left, right);
-    assert.deepEqual(reduceRewriteLifecycle(initial, { ...action, verdicts: verdicts.slice(0, 2) }, context), { ok: false, error: 'invalid_verdict_count' });
-});
-test('enforces replay, parent order, terminal states, bindings, and evaluator authority', () => {
-    const reviewTask = task();
-    const initial = createInitialLifecycleArtifact(reviewTask, deterministic());
-    const action = { version: '1', type: 'semantic_submission', parentArtifactFingerprint: initial.artifactFingerprint, taskFingerprint: reviewTask.taskFingerprint, verdicts: [parseSemanticVerdict(reviewTask, 'one', { approved: true, violations: [] })] };
-    const next = reduceRewriteLifecycle(initial, action, context);
-    assert.equal(next.ok, true);
-    if (!next.ok)
-        return;
-    assert.strictEqual(reduceRewriteLifecycle(next.artifact, action, context).ok, true);
-    assert.deepEqual(reduceRewriteLifecycle(next.artifact, { ...action, verdicts: [parseSemanticVerdict(reviewTask, 'one', { approved: false, violations: ['action_change'] })] }, context), { ok: false, error: 'conflicting_replay' });
-    assert.deepEqual(reduceRewriteLifecycle(initial, { ...action, parentArtifactFingerprint: '9'.repeat(64) }, context), { ok: false, error: 'stale_parent' });
-    assert.deepEqual(reduceRewriteLifecycle(initial, { ...action, verdicts: [parseSemanticVerdict(reviewTask, 'unknown', { approved: true, violations: [] })] }, context), { ok: false, error: 'evaluator_not_authorized' });
-    const terminal = reduceRewriteLifecycle(createInitialLifecycleArtifact(reviewTask, deterministic()), { ...action, verdicts: [parseSemanticVerdict(reviewTask, 'one', { approved: false, violations: ['action_change'] })] }, context);
-    if (terminal.ok)
-        assert.deepEqual(reduceRewriteLifecycle(terminal.artifact, { ...action, parentArtifactFingerprint: terminal.artifact.artifactFingerprint }, context), { ok: false, error: 'terminal_state' });
-});
-test('authorized human rejection escalates; approval requires a valid external capability', () => {
-    const reviewTask = task();
-    const initial = createInitialLifecycleArtifact(reviewTask, deterministic());
-    const semantic = reduceRewriteLifecycle(initial, { version: '1', type: 'semantic_submission', parentArtifactFingerprint: initial.artifactFingerprint, taskFingerprint: reviewTask.taskFingerprint, verdicts: [parseSemanticVerdict(reviewTask, 'one', { approved: true, violations: [] })] }, context);
-    assert.equal(semantic.ok, true);
-    if (!semantic.ok)
-        return;
-    const approvalBase = { version: '1', judgmentType: 'human_finalization', parentArtifactFingerprint: semantic.artifact.artifactFingerprint, binding, evaluatorId: 'human-1', evidenceScope: { kind: 'candidate' }, decision: 'approve' };
-    assert.deepEqual(reduceRewriteLifecycle(semantic.artifact, { version: '1', type: 'human_finalization', parentArtifactFingerprint: semantic.artifact.artifactFingerprint, finalization: approvalBase }, context), { ok: false, error: 'capability_required' });
-    assert.deepEqual(reduceRewriteLifecycle(semantic.artifact, { version: '1', type: 'human_finalization', parentArtifactFingerprint: semantic.artifact.artifactFingerprint, finalization: { ...approvalBase, capability: { payload: 'bad', signature: 'bad' } } }, context), { ok: false, error: 'capability_invalid' });
-    const rejection = reduceRewriteLifecycle(semantic.artifact, { version: '1', type: 'human_finalization', parentArtifactFingerprint: semantic.artifact.artifactFingerprint, finalization: { version: '1', judgmentType: 'human_finalization', parentArtifactFingerprint: semantic.artifact.artifactFingerprint, binding, evaluatorId: 'human-1', evidenceScope: { kind: 'candidate' }, decision: 'reject' } }, context);
-    assert.equal(rejection.ok && rejection.artifact.status, 'needs_escalation');
-    const { publicKey, privateKey } = generateKeyPairSync('ed25519');
-    const trustStore = { version: '1', audience: '@holdyourvoice/hyv', maxCapabilityLifetimeSeconds: 300, keys: [{ issuer: 'host', keyId: 'k1', publicKeySpki: publicKey.export({ type: 'spki', format: 'der' }).toString('base64url'), status: 'active' }] };
-    const claims = { version: '1', purpose: 'hyv.final-approval', issuer: 'host', audience: '@holdyourvoice/hyv', subjectArtifactFingerprint: semantic.artifact.artifactFingerprint, sourceHash: binding.sourceHash, candidateHash: binding.candidateHash, profileId: binding.profileId, profileRevisionDigest: binding.profileRevisionDigest, keyId: 'k1', issuedAt: 100, notBefore: 100, expiresAt: 200, nonce: 'nonce' };
-    const payload = canonicalJsonBytes(claims);
-    const capability = { payload: payload.toString('base64url'), signature: sign(null, payload, privateKey).toString('base64url') };
-    const approved = reduceRewriteLifecycle(semantic.artifact, { version: '1', type: 'human_finalization', parentArtifactFingerprint: semantic.artifact.artifactFingerprint, finalization: { version: '1', judgmentType: 'human_finalization', parentArtifactFingerprint: semantic.artifact.artifactFingerprint, binding, evaluatorId: 'human-1', evidenceScope: { kind: 'candidate' }, decision: 'approve', capability } }, { ...context, trustStore });
-    assert.equal(approved.ok && approved.artifact.status, 'approved');
-    assert.doesNotMatch(JSON.stringify(approved), /nonce|payload|signature/);
-});
-test('failed deterministic verification cannot create an initial lifecycle artifact', () => {
-    assert.throws(() => createInitialLifecycleArtifact(task(), deterministic(false)), /passed deterministic verification/);
-    const reviewTask = task();
-    assert.throws(() => createInitialLifecycleArtifact({ ...reviewTask, evidenceScope: { sentenceIds: [99] } }, deterministic()), /passed deterministic verification/);
-});
-test('rejects oversized or deeply nested actions as invalid without throwing', () => {
-    const reviewTask = task();
-    const initial = createInitialLifecycleArtifact(reviewTask, deterministic());
-    const verdict = parseSemanticVerdict(reviewTask, 'one', { approved: true, violations: [] });
-    const oversized = { version: '1', type: 'semantic_submission', parentArtifactFingerprint: initial.artifactFingerprint, taskFingerprint: reviewTask.taskFingerprint, verdicts: Array.from({ length: 1000 }, () => verdict) };
-    assert.deepEqual(reduceRewriteLifecycle(initial, oversized, context), { ok: false, error: 'invalid_action' });
-    let nested = 'x';
-    for (let index = 0; index < 70; index += 1)
-        nested = [nested];
-    assert.deepEqual(reduceRewriteLifecycle(initial, { ...oversized, verdicts: [{ ...verdict, binding: nested }] }, context), { ok: false, error: 'invalid_action' });
-    const malformedFinalization = { version: '1', type: 'human_finalization', parentArtifactFingerprint: initial.artifactFingerprint, finalization: { version: '1', judgmentType: 'human_finalization', parentArtifactFingerprint: initial.artifactFingerprint, binding, evaluatorId: 'human-1', evidenceScope: null, decision: 'reject' } };
-    assert.deepEqual(reduceRewriteLifecycle(initial, malformedFinalization, context), { ok: false, error: 'invalid_action' });
-});
-test('semantic submissions reject changed task, binding, and evidence scope', () => {
-    const reviewTask = task();
-    const initial = createInitialLifecycleArtifact(reviewTask, deterministic());
-    const verdict = parseSemanticVerdict(reviewTask, 'one', { approved: true, violations: [] });
-    const base = { version: '1', type: 'semantic_submission', parentArtifactFingerprint: initial.artifactFingerprint, taskFingerprint: reviewTask.taskFingerprint, verdicts: [verdict] };
-    assert.deepEqual(reduceRewriteLifecycle(initial, { ...base, taskFingerprint: '9'.repeat(64) }, context), { ok: false, error: 'task_fingerprint_mismatch' });
-    assert.deepEqual(reduceRewriteLifecycle(initial, { ...base, verdicts: [{ ...verdict, binding: { ...binding, candidateHash: '9'.repeat(64) } }] }, context), { ok: false, error: 'invalid_binding' });
-    assert.deepEqual(reduceRewriteLifecycle(initial, { ...base, verdicts: [{ ...verdict, evidenceScope: { sentenceIds: [99] } }] }, context), { ok: false, error: 'evidence_scope_mismatch' });
-});

package/dist/stage1-dry-run.test.js

@@ -1,39 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, symlinkSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-test('synthetic Stage 1 packet executes outside the repository and remains blocked', () => {
-    const parent = mkdtempSync(join(tmpdir(), 'hyv-stage1-dry-run-test-'));
-    const outputRoot = join(parent, 'packet');
-    try {
-        const output = JSON.parse(execFileSync(process.execPath, ['scripts/run-stage1-dry-run.mjs', '--out', outputRoot], { encoding: 'utf8' }));
-        assert.equal(output.decision, 'BLOCKED');
-        assert.equal(output.promotable, false);
-        assert.deepEqual(output.blockers, ['human_writer_evidence_deferred', 'synthetic_fixture_evidence', 'locked_human_evidence_required']);
-        const report = JSON.parse(readFileSync(join(outputRoot, 'report.json'), 'utf8'));
-        assert.equal(report.decision, 'BLOCKED');
-        assert.equal(report.promotable, false);
-        assert.match(report.reportDigest, /^[a-f0-9]{64}$/);
-    }
-    finally {
-        rmSync(parent, { recursive: true, force: true });
-    }
-});
-test('synthetic Stage 1 packet refuses repository output', () => {
-    assert.throws(() => execFileSync(process.execPath, ['scripts/run-stage1-dry-run.mjs', '--out', join(process.cwd(), 'stage1-output')], { stdio: 'pipe' }), /Dry-run output must stay outside the repository/);
-});
-test('synthetic Stage 1 packet refuses a symlinked ancestor into the repository', () => {
-    const parent = mkdtempSync(join(tmpdir(), 'hyv-stage1-symlink-test-'));
-    const repositoryTarget = join(process.cwd(), 'stage1-symlink-target');
-    mkdirSync(repositoryTarget);
-    symlinkSync(repositoryTarget, join(parent, 'redirect'));
-    try {
-        assert.throws(() => execFileSync(process.execPath, ['scripts/run-stage1-dry-run.mjs', '--out', join(parent, 'redirect', 'packet')], { stdio: 'pipe' }), /Dry-run output must stay outside the repository/);
-    }
-    finally {
-        rmSync(parent, { recursive: true, force: true });
-        rmSync(repositoryTarget, { recursive: true, force: true });
-    }
-});