@holdyourvoice/hyv 3.5.1 → 3.6.1

package/dist/cli/lifecycle.js

@@ -0,0 +1,162 @@
+import { writeFileSync } from 'node:fs';
+import { clearLearning, composeLearning, inspectLearning, migrateLearningV2ToV3, profileFingerprint, ratifyLearningEvent, recordLearningInstruction, supersedeLearningEvent } from '../learning.js';
+import { canonicalJson } from '../canonical-json.js';
+import { finalizeLifecycle, inspectLifecycle, prepareLifecycle, recordApprovedLearning, submitSemanticVerdict, validateFinalApproval } from '../lifecycle-adapter.js';
+import { loadApprovalContext } from '../approval-context.js';
+import { input, readJson, capabilityArguments, readProfile, prepareContext, json, canonical } from './io.js';
+function requireProfileV3(profile) {
+    if (profile.version !== '3')
+        throw new Error('This learning operation requires a Profile v3.');
+    return profile;
+}
+function learningArguments(args) {
+    const values = [];
+    const options = {};
+    for (const argument of args) {
+        if (!argument.startsWith('--')) {
+            values.push(argument);
+            continue;
+        }
+        const [name, ...parts] = argument.slice(2).split('=');
+        const value = parts.join('=').trim();
+        if (!value)
+            throw new Error(`Learning option --${name} requires a value.`);
+        if (name === 'mutation-id' && value.length <= 200)
+            options.mutationId = value;
+        else if (name === 'authority' && ['founder', 'team', 'system'].includes(value))
+            options.authority = value;
+        else if (name === 'provenance' && value.length <= 500)
+            options.provenance = value;
+        else if (name === 'weight' && Number.isFinite(Number(value)) && Number(value) > 0)
+            options.weight = Number(value);
+        else if (name === 'compatibility' && ['same-or-newer', 'exact'].includes(value))
+            options.compatibility = value;
+        else
+            throw new Error(`Invalid learning option: --${name}=${value}`);
+    }
+    return { values, options };
+}
+export function runLifecycle(args) {
+    const [action, ...raw] = args;
+    if (action === 'prepare-semantic')
+        return prepareSemanticLifecycle(raw);
+    if (action === 'submit-verdict')
+        return submitLifecycleVerdict(raw);
+    if (action === 'inspect')
+        return inspectLifecycleArtifact(raw);
+    if (action === 'validate-final-approval' || action === 'finalize')
+        return finishLifecycle(action, raw);
+    throw new Error('Usage: hyv lifecycle <prepare-semantic|submit-verdict|inspect|validate-final-approval|finalize> ...');
+}
+function prepareSemanticLifecycle(args) {
+    const [deterministicPath, bindingPath, receiptPath, policy, violationsPath, output, ...extra] = args;
+    if (!deterministicPath || !bindingPath || !receiptPath || !policy || !violationsPath || !output || extra.length || !['normal', 'high_assurance'].includes(policy))
+        throw new Error('Usage: hyv lifecycle prepare-semantic deterministic.json binding.json receipt.json <normal|high_assurance> violations.json output.json');
+    if (policy === 'high_assurance')
+        throw new Error('High-assurance semantic review requires a trusted embedding.');
+    const result = prepareLifecycle(readJson(deterministicPath), readJson(bindingPath), readJson(receiptPath), policy, readJson(violationsPath));
+    const serialized = canonicalJson(result);
+    writeFileSync(output, `${serialized}\n`, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    process.stdout.write(`${serialized}\n`);
+    return 0;
+}
+function submitLifecycleVerdict(args) {
+    const [artifactPath, taskPath, evaluatorId, verdictPath, ...extra] = args;
+    if (!artifactPath || !taskPath || !evaluatorId || !verdictPath || extra.length)
+        throw new Error('Usage: hyv lifecycle submit-verdict artifact.json task.json evaluator-id verdict.json');
+    const artifact = readJson(artifactPath);
+    const task = readJson(taskPath);
+    if (task.policy !== 'normal')
+        throw new Error('High-assurance semantic review requires a trusted embedding.');
+    const result = submitSemanticVerdict(artifact, task, evaluatorId, readJson(verdictPath), loadApprovalContext());
+    canonical(result.ok ? result.artifact : { error: result.error });
+    return result.ok && result.artifact.status === 'ready_for_human_review' ? 0 : 2;
+}
+function inspectLifecycleArtifact(args) {
+    const [artifactPath, ...extra] = args;
+    if (!artifactPath || extra.length)
+        throw new Error('Usage: hyv lifecycle inspect artifact.json');
+    canonical(inspectLifecycle(readJson(artifactPath)));
+    return 0;
+}
+function finishLifecycle(action, args) {
+    const { values, capability } = capabilityArguments(args);
+    if (action === 'validate-final-approval') {
+        const [artifactPath, ...extra] = values;
+        if (!artifactPath || extra.length || !capability)
+            throw new Error('Usage: hyv lifecycle validate-final-approval artifact.json (--capability-stdin|--capability-file path)');
+        const result = validateFinalApproval(readJson(artifactPath), capability, loadApprovalContext());
+        canonical(result);
+        return result.ok ? 0 : 2;
+    }
+    const [artifactPath, decisionPath, ...extra] = values;
+    if (!artifactPath || !decisionPath || extra.length)
+        throw new Error('Usage: hyv lifecycle finalize artifact.json decision.json [--capability-stdin|--capability-file path]');
+    const decision = readJson(decisionPath);
+    if (decision.decision === 'approve' && !capability)
+        throw new Error('Approval requires a capability.');
+    if (decision.decision === 'reject' && capability)
+        throw new Error('Rejection does not accept a capability.');
+    const result = finalizeLifecycle(readJson(artifactPath), decision, loadApprovalContext(), capability);
+    canonical(result.ok ? result.artifact : { error: result.error });
+    return result.ok && result.artifact.status === 'approved' ? 0 : 2;
+}
+export function runLearning(args) {
+    const [action, ...raw] = args;
+    if (action === 'record-approved')
+        return runRecordApprovedLearning(raw);
+    const { values, options } = learningArguments(raw);
+    const [profilePath, ...operands] = values;
+    if (!action || !profilePath)
+        throw new Error('Usage: hyv learning <show|inspect|add|record|ratify|supersede|migrate|clear> profile.json [value] [options]');
+    const profile = readProfile(profilePath);
+    if (action === 'show') {
+        json({ profile: profileFingerprint(profile), preferences: composeLearning(profile, options) });
+        return 0;
+    }
+    if (action === 'inspect') {
+        if (Object.keys(options).length)
+            throw new Error('Usage: hyv learning inspect profile.json');
+        json(inspectLearning(profile));
+        return 0;
+    }
+    if (action === 'add' || action === 'record') {
+        const text = operands.join(' ').trim();
+        if (!text)
+            throw new Error('Usage: hyv learning record profile.json "instruction" [options]');
+        const result = recordLearningInstruction(profile, text, options);
+        json(action === 'add' ? { added: result.status === 'recorded' } : result);
+        return 0;
+    }
+    if (action === 'ratify' || action === 'supersede') {
+        const [eventId, ...extra] = operands;
+        if (!eventId || extra.length)
+            throw new Error(`Usage: hyv learning ${action} profile.json event-id [options]`);
+        json(action === 'ratify' ? ratifyLearningEvent(requireProfileV3(profile), eventId, options) : supersedeLearningEvent(requireProfileV3(profile), eventId, options));
+        return 0;
+    }
+    if (action === 'migrate') {
+        const [targetPath, ...extra] = operands;
+        if (!targetPath || extra.length || profile.version !== '2')
+            throw new Error('Usage: hyv learning migrate source-v2.json target-v3.json [options]');
+        json(migrateLearningV2ToV3(profile, requireProfileV3(readProfile(targetPath)), options));
+        return 0;
+    }
+    if (action === 'clear') {
+        if (operands.length || Object.keys(options).length)
+            throw new Error('Usage: hyv learning clear profile.json');
+        json({ cleared: clearLearning(profile) });
+        return 0;
+    }
+    throw new Error('Usage: hyv learning <show|inspect|add|record|ratify|supersede|migrate|clear> profile.json [value] [options]');
+}
+function runRecordApprovedLearning(args) {
+    const { values, capability } = capabilityArguments(args);
+    const [readyPath, approvedPath, originalPath, candidatePath, profilePath, decisionPath, ...contextPaths] = values;
+    if (!readyPath || !approvedPath || !originalPath || !candidatePath || !profilePath || !decisionPath || !capability)
+        throw new Error('Usage: hyv learning record-approved ready.json approved.json original.md candidate.md profile.json decision.json [copy-spec.json] [writing-brief.json] (--capability-stdin|--capability-file path)');
+    const context = prepareContext(contextPaths);
+    const status = recordApprovedLearning({ ready: readJson(readyPath), approved: readJson(approvedPath), decision: readJson(decisionPath), capability, source: input(originalPath), candidate: input(candidatePath), profile: readProfile(profilePath), context: loadApprovalContext(), copySpec: context.copySpec, writingBrief: context.writingBrief });
+    canonical({ status });
+    return status === 'write_failed' ? 2 : 0;
+}

package/dist/cli/profiles.js

@@ -0,0 +1,246 @@
+import { lstatSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join } from 'node:path';
+import { buildProfile, buildProfileV3 } from '../voice-dna.js';
+import { assessProfileReadiness } from '../profile-quality.js';
+import { composeTeamProfile, parseTeamProfileBundle } from '../team-profile.js';
+import { composeProfiles, parseProfileRatio } from '../profile-compose.js';
+import { scoreHeldoutProfile } from '../profile-score.js';
+import { ingestGmailSentMbox, ingestTelegramDesktopJson } from '../sample-ingest.js';
+import { evaluateIsolatedBacktest } from '../backtest.js';
+import { watchProfileSamples } from '../profile-watch.js';
+import { evaluateLocalComposite } from '../local-eval.js';
+import { input, readJson, readProfile, json, writeJson } from './io.js';
+function profileArguments(args) {
+    const [output, ...rest] = args;
+    const samples = [];
+    const avoid = [];
+    for (const argument of rest) {
+        if (argument.startsWith('--avoid=')) {
+            const phrase = argument.slice('--avoid='.length).trim();
+            if (!phrase)
+                throw new Error('Avoid phrases must use --avoid=phrase.');
+            avoid.push(phrase);
+        }
+        else {
+            samples.push(argument);
+        }
+    }
+    if (!output || samples.length < 2)
+        throw new Error('Usage: hyv profile profile.json sample-a.md sample-b.md [sample-c.md] [--avoid=phrase]');
+    return { output, samples, avoid };
+}
+async function runProfileWatch(args) {
+    const [output, ...rest] = args;
+    const samples = [];
+    let id = '';
+    let channel;
+    let debounceMs = 500;
+    for (const value of rest) {
+        if (value.startsWith('--id='))
+            id = value.slice('--id='.length);
+        else if (value.startsWith('--channel='))
+            channel = value.slice('--channel='.length);
+        else if (value.startsWith('--debounce-ms='))
+            debounceMs = Number(value.slice('--debounce-ms='.length));
+        else
+            samples.push(value);
+    }
+    if (!output || !isAbsolute(output) || !id || !channel || samples.length < 2)
+        throw new Error('Usage: hyv profile watch /absolute/profile.json --id=writer.channel --channel=email sample-a.md sample-b.md [--debounce-ms=500]');
+    outputOutsideGitCheckout(dirname(output));
+    let initial = true;
+    const rebuild = () => {
+        const profile = buildProfileV3(samples.map(input), id, channel);
+        writeFileSync(output, JSON.stringify(profile, null, 2) + '\n', { encoding: 'utf8', flag: initial ? 'wx' : 'w', mode: 0o600 });
+        initial = false;
+        json({ version: '1', status: 'rebuilt', sampleCount: samples.length, profileId: profile.id, revisionDigest: profile.revisionDigest });
+    };
+    rebuild();
+    const handle = watchProfileSamples({ samples, debounceMs, rebuild });
+    await new Promise((resolve) => process.once('SIGINT', resolve));
+    handle.close();
+    return 0;
+}
+export function runProfile(args) {
+    if (args[0] === 'watch')
+        return runProfileWatch(args.slice(1));
+    if (args[0] === 'assess') {
+        if (args.length < 3)
+            throw new Error('Usage: hyv profile assess sample-a.md sample-b.md [sample-c.md]');
+        json(assessProfileReadiness(args.slice(1).map(input)));
+        return 0;
+    }
+    if (args[0] === 'compose') {
+        const rest = args.slice(1);
+        const ratioIndex = rest.findIndex((value) => value === '--ratio' || value.startsWith('--ratio='));
+        if (ratioIndex < 0)
+            throw new Error('Usage: hyv profile compose --ratio 70:30 profile-a.json profile-b.json [profile-c.json]');
+        const ratio = rest[ratioIndex] === '--ratio' ? rest[ratioIndex + 1] : rest[ratioIndex].slice('--ratio='.length);
+        const profilePaths = rest.filter((_, index) => index !== ratioIndex && index !== ratioIndex + Number(rest[ratioIndex] === '--ratio'));
+        if (!ratio || profilePaths.length < 2)
+            throw new Error('Usage: hyv profile compose --ratio 70:30 profile-a.json profile-b.json [profile-c.json]');
+        const profiles = profilePaths.map(readProfile);
+        if (profiles.some((profile) => profile.version !== '3'))
+            throw new Error('Profile composition requires Profile v3 inputs.');
+        json(composeProfiles(profiles, parseProfileRatio(ratio, profiles.length)));
+        return 0;
+    }
+    if (args[0] === 'v3') {
+        const [output, ...rest] = args.slice(1);
+        const samples = [];
+        const avoid = [];
+        let id = '';
+        let channel;
+        let tone;
+        for (const argument of rest) {
+            if (argument.startsWith('--id='))
+                id = argument.slice('--id='.length);
+            else if (argument.startsWith('--channel='))
+                channel = argument.slice('--channel='.length);
+            else if (argument.startsWith('--avoid='))
+                avoid.push(argument.slice('--avoid='.length));
+            else if (argument.startsWith('--tone=')) {
+                const values = argument.slice('--tone='.length).split(',').map(Number);
+                if (values.length !== 5 || values.some((value) => !Number.isFinite(value) || value < 0 || value > 1))
+                    throw new Error('Tone must use five 0–1 comma-separated values: formality,confidence,warmth,energy,complexity.');
+                tone = { formality: values[0], confidence: values[1], warmth: values[2], energy: values[3], complexity: values[4] };
+            }
+            else
+                samples.push(argument);
+        }
+        if (!output || !id || !channel || samples.length < 2)
+            throw new Error('Usage: hyv profile v3 profile.json --id=writer.channel --channel=email sample-a.md sample-b.md [--tone=0,0,0,0,0] [--avoid=phrase]');
+        writeJson(output, buildProfileV3(samples.map(input), id, channel, avoid, tone));
+        return 0;
+    }
+    const { output, samples, avoid } = profileArguments(args);
+    writeJson(output, buildProfile(samples.map(input), avoid));
+    return 0;
+}
+export function runScore(args) {
+    const [draftPath, profilePath, ...rest] = args;
+    if (!draftPath || !profilePath)
+        throw new Error('Usage: hyv score draft.md profile.json heldout-a.md heldout-b.md heldout-c.md [--channel=channel]');
+    const samplePaths = [];
+    let channel;
+    for (const value of rest) {
+        if (value.startsWith('--channel='))
+            channel = value.slice('--channel='.length);
+        else
+            samplePaths.push(value);
+    }
+    if (samplePaths.length < 3)
+        throw new Error('Usage: hyv score draft.md profile.json heldout-a.md heldout-b.md heldout-c.md [--channel=channel]');
+    json(scoreHeldoutProfile(input(draftPath), readProfile(profilePath), samplePaths.map(input), channel));
+    return 0;
+}
+export function runBacktest(args) {
+    const [contextPath, targetPath, candidatePath, profilePath, ...heldoutPaths] = args;
+    if (!contextPath || !targetPath || !candidatePath || !profilePath || heldoutPaths.length < 3)
+        throw new Error('Usage: hyv backtest context.md heldout-target.md candidate.md profile.json heldout-a.md heldout-b.md heldout-c.md');
+    json(evaluateIsolatedBacktest(input(contextPath), input(targetPath), input(candidatePath), readProfile(profilePath), heldoutPaths.map(input)));
+    return 0;
+}
+function readEvalParagraphs(path, label) {
+    const value = readJson(path);
+    if (!Array.isArray(value) || !value.every((item) => item && typeof item === 'object' && typeof item.paragraph_id === 'string' && typeof item.text === 'string'))
+        throw new Error(`${label} must be a JSON array of { paragraph_id, text } values.`);
+    return value.map((item) => ({ paragraphId: item.paragraph_id, text: item.text }));
+}
+export function runEvaluateLocal(args) {
+    const [inputPath, candidatePath, userPath, aiShadowPath] = args;
+    if (!inputPath || !candidatePath || !userPath || !aiShadowPath || args.length !== 4)
+        throw new Error('Usage: hyv evaluate-local input.md candidate.md user-paragraphs.json ai-shadow-paragraphs.json');
+    json(evaluateLocalComposite(input(inputPath), input(candidatePath), readEvalParagraphs(userPath, 'User paragraphs'), readEvalParagraphs(aiShadowPath, 'AI-shadow paragraphs')));
+    return 0;
+}
+function outputOutsideGitCheckout(path) {
+    if (!isAbsolute(path))
+        throw new Error('Sample ingest output must be an absolute path outside a Git checkout.');
+    let current;
+    try {
+        const stats = lstatSync(path);
+        if (!stats.isDirectory() || stats.isSymbolicLink())
+            throw new Error('Sample ingest output directory must be an existing non-symlink directory outside a Git checkout.');
+        current = realpathSync(path);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('Sample ingest output directory'))
+            throw error;
+        throw new Error('Sample ingest output directory must already exist and remain outside a Git checkout.');
+    }
+    for (;;) {
+        try {
+            lstatSync(join(current, '.git'));
+            throw new Error('Sample ingest output must be outside a Git checkout.');
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'Sample ingest output must be outside a Git checkout.')
+                throw error;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return;
+        current = parent;
+    }
+}
+export function runIngest(args) {
+    const [sourceType, sourcePath, ...options] = args;
+    let owner = '';
+    let output = '';
+    const blockedWords = [];
+    for (const option of options) {
+        if (option.startsWith('--owner='))
+            owner = option.slice('--owner='.length);
+        else if (option.startsWith('--output='))
+            output = option.slice('--output='.length);
+        else if (option.startsWith('--blocked='))
+            blockedWords.push(option.slice('--blocked='.length));
+        else
+            throw new Error('Usage: hyv ingest <gmail-sent-mbox|telegram-desktop-json> export --owner=owner --output=/absolute/safe-directory [--blocked=word]');
+    }
+    if (!sourcePath || !owner || !output || !['gmail-sent-mbox', 'telegram-desktop-json'].includes(sourceType ?? ''))
+        throw new Error('Usage: hyv ingest <gmail-sent-mbox|telegram-desktop-json> export --owner=owner --output=/absolute/safe-directory [--blocked=word]');
+    outputOutsideGitCheckout(output);
+    const result = sourceType === 'gmail-sent-mbox'
+        ? ingestGmailSentMbox(input(sourcePath), owner, blockedWords)
+        : ingestTelegramDesktopJson(input(sourcePath), owner, blockedWords);
+    const outputDirectory = realpathSync(output);
+    const samplesPath = join(outputDirectory, 'samples.jsonl');
+    const receiptPath = join(outputDirectory, 'receipt.json');
+    try {
+        writeFileSync(samplesPath, result.samples.map((sample) => JSON.stringify({ text: sample })).join('\n') + (result.samples.length ? '\n' : ''), { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            throw new Error('Sample ingest output directory must already exist and remain outside a Git checkout.');
+        throw error;
+    }
+    try {
+        writeFileSync(receiptPath, JSON.stringify(result.receipt, null, 2) + '\n', { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        try {
+            rmSync(samplesPath, { force: true });
+        }
+        catch { }
+        throw error;
+    }
+    json(result.receipt);
+    return 0;
+}
+export function runTeamProfile(args) {
+    const [action, bundlePath, authorPath, ...brandPaths] = args;
+    if (action === 'validate' && bundlePath && !authorPath) {
+        json(parseTeamProfileBundle(readJson(bundlePath)));
+        return 0;
+    }
+    if (action === 'compose' && bundlePath && authorPath) {
+        const brands = brandPaths.map(readProfile).filter((profile) => profile.version === '3');
+        if (brands.length !== brandPaths.length)
+            throw new Error('Team brand profiles must use Profile v3.');
+        json(composeTeamProfile(readProfile(authorPath), brands, parseTeamProfileBundle(readJson(bundlePath))));
+        return 0;
+    }
+    throw new Error('Usage: hyv team-profile <validate bundle.json|compose bundle.json author-profile.json [brand-profile.json...]>');
+}

package/dist/cli/rewriting.js

@@ -0,0 +1,111 @@
+import { parseCopySpec } from '../copy-spec.js';
+import { composeLearning } from '../learning.js';
+import { rewritePrompt } from '../pipeline.js';
+import { evaluateRewriteResponse, parseRewriteTask, prepareRewriteTask } from '../rewrite-task.js';
+import { parseJudgmentEnvelope, preparePostCandidateJudgment, preparePreEditJudgment, reducePostCandidate, reducePreEdit } from '../judgment-task.js';
+import { evaluateRebuildResponse, parseRebuildTask, prepareRebuildTask, writerRequestForRebuild } from '../rebuild-task.js';
+import { loadApprovalContext } from '../approval-context.js';
+import { findWritingExamples } from '../writing-examples.js';
+import { input, readJson, capabilityArguments, readProfile, readBrief, prepareContext, json, writeJson } from './io.js';
+function rebuildArguments(args) {
+    const values = [];
+    let policyPath;
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] !== '--recomposition-policy') {
+            values.push(args[index]);
+            continue;
+        }
+        const path = args[index + 1];
+        if (policyPath || !path || path === '-' || path.startsWith('--'))
+            throw new Error('Choose one recomposition policy file.');
+        policyPath = path;
+        index += 1;
+    }
+    const capability = capabilityArguments(values);
+    return { ...capability, ...(policyPath ? { recompositionPolicy: readJson(policyPath) } : {}) };
+}
+export function runRewritePrompt(args) {
+    const [draft, profilePath, ...rest] = args;
+    const exampleOption = rest.find((value) => value.startsWith('--examples-json='));
+    const briefPaths = rest.filter((value) => !value.startsWith('--'));
+    const briefPath = briefPaths[0];
+    if (!draft || !profilePath || briefPaths.length > 1 || rest.some((value) => value.startsWith('--') && !value.startsWith('--examples-json=')))
+        throw new Error('Usage: hyv rewrite-prompt draft.md profile.json [writing-brief.json] [--examples-json=local-examples.json]');
+    const profile = readProfile(profilePath);
+    const examplesValue = exampleOption ? readJson(exampleOption.slice('--examples-json='.length)) : undefined;
+    if (examplesValue !== undefined && (!Array.isArray(examplesValue) || !examplesValue.every((item) => item && typeof item === 'object' && typeof item.basename === 'string' && typeof item.text === 'string')))
+        throw new Error('Local examples must be a JSON array of { basename, text } values.');
+    const draftText = input(draft);
+    console.log(rewritePrompt(draftText, profile, composeLearning(profile), readBrief(briefPath), examplesValue ? findWritingExamples(draftText, examplesValue) : []));
+    return 0;
+}
+export function runPrepareRewrite(args) {
+    const [draft, profilePath, output, ...contextPaths] = args;
+    if (!draft || !profilePath || !output)
+        throw new Error('Usage: hyv prepare-rewrite draft.md profile.json task.json [copy-spec.json] [writing-brief.json]');
+    const context = prepareContext(contextPaths);
+    const task = prepareRewriteTask(input(draft), readProfile(profilePath), context.copySpec, context.writingBrief);
+    writeJson(output, task);
+    json({ version: task.version, fingerprint: task.fingerprint, eligibleSentenceIds: task.eligibleSentenceIds });
+    return 0;
+}
+export function runApplyRewrite(args) {
+    const [taskPath, responsePath, profilePath] = args;
+    if (!taskPath || !responsePath || !profilePath)
+        throw new Error('Usage: hyv apply-rewrite task.json response.json profile.json');
+    const result = evaluateRewriteResponse(parseRewriteTask(JSON.parse(input(taskPath))), input(responsePath), readProfile(profilePath));
+    json(result);
+    return result.status === 'accepted' ? 0 : 2;
+}
+export function runPrepareJudgment(args) {
+    const [stage, kind, draft, profilePath, output, candidatePath] = args;
+    if (!stage || !kind || !draft || !profilePath || !output)
+        throw new Error('Usage: hyv prepare-judgment pre-edit|post-candidate kind draft.md profile.json task.json [candidate.md]');
+    if (stage === 'post-candidate' && !candidatePath)
+        throw new Error('Usage: hyv prepare-judgment post-candidate kind draft.md profile.json task.json candidate.md');
+    const profile = readProfile(profilePath);
+    const task = stage === 'pre-edit'
+        ? preparePreEditJudgment(input(draft), profile, kind)
+        : preparePostCandidateJudgment(input(draft), input(candidatePath ?? ''), profile, kind);
+    writeJson(output, task);
+    json({ version: task.version, stage: task.stage, judgmentType: task.judgmentType, taskFingerprint: task.taskFingerprint });
+    return 0;
+}
+export function runReduceJudgment(args) {
+    if (args.length < 3)
+        throw new Error('Usage: hyv reduce-judgment envelope.json envelope.json [envelope.json...]');
+    const envelopes = args.map((path) => parseJudgmentEnvelope(JSON.parse(input(path))));
+    json(envelopes[0]?.stage === 'pre-edit' ? reducePreEdit(envelopes) : reducePostCandidate(envelopes));
+    return 0;
+}
+export function runPrepareRebuild(args) {
+    const { values, capability, recompositionPolicy } = rebuildArguments(args);
+    const [draft, profilePath, reductionPath, specPath, output, briefPath] = values;
+    if (!draft || !profilePath || !reductionPath || !specPath || !output || !capability) {
+        throw new Error('Usage: hyv prepare-rebuild draft.md profile.json reduction.json copy-spec.json task.json [writing-brief.json] [--recomposition-policy policy.json] (--capability-stdin|--capability-file path)');
+    }
+    const context = loadApprovalContext();
+    const task = prepareRebuildTask(input(draft), readProfile(profilePath), readJson(reductionPath), parseCopySpec(JSON.parse(input(specPath))), capability, context.trustStore, context.now, readBrief(briefPath), recompositionPolicy);
+    writeJson(output, task);
+    json({ version: task.version, fingerprint: task.fingerprint, recommendationFingerprint: task.recommendationFingerprint, authorizationFingerprint: task.authorizationFingerprint, ...(task.recompositionPolicy ? { recompositionPolicy: task.recompositionPolicy } : {}) });
+    return 0;
+}
+export function runApplyRebuild(args) {
+    const { values, capability } = capabilityArguments(args);
+    const [taskPath, responsePath, profilePath, ...extra] = values;
+    if (!taskPath || !responsePath || !profilePath || extra.length || !capability)
+        throw new Error('Usage: hyv apply-rebuild task.json response.json profile.json (--capability-stdin|--capability-file path)');
+    const context = loadApprovalContext();
+    const result = evaluateRebuildResponse(parseRebuildTask(JSON.parse(input(taskPath))), input(responsePath), readProfile(profilePath), capability, context.trustStore, context.now);
+    json(result);
+    return result.status === 'accepted' ? 0 : 2;
+}
+export function runRebuildWriterRequest(args) {
+    const [taskPath, output, ...extra] = args;
+    if (!taskPath || !output || extra.length)
+        throw new Error('Usage: hyv rebuild-writer-request task.json writer-request.json');
+    const request = writerRequestForRebuild(parseRebuildTask(JSON.parse(input(taskPath))));
+    writeJson(output, request);
+    json({ version: request.version, taskFingerprint: request.taskFingerprint, copySpecFingerprint: request.copySpecFingerprint, ...(request.recompositionPolicyFingerprint ? { recompositionPolicyFingerprint: request.recompositionPolicyFingerprint } : {}) });
+    return 0;
+}