@holdyourvoice/hyv 3.6.0 → 4.0.0

package/dist/cli/checks.js

@@ -0,0 +1,226 @@
+import { linkSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, extname, join, resolve } from 'node:path';
+import { RULESET_VERSION, serializedRules } from '../ai-editor.js';
+import { parseCopySpec } from '../copy-spec.js';
+import { analyzeBatch } from '../editorial-packs.js';
+import { cleanHygiene, finalOutputCheck, inspectHygiene } from '../hygiene.js';
+import { applyHiddenTextPolicy, inspectHiddenText, parseHiddenTextPolicy } from '../hidden-text.js';
+import { analyze, verify, verifyWithCopySpec } from '../pipeline.js';
+import { formatFactLintReport, lintFacts } from '../fact-linter.js';
+import { lintLogic } from '../logic-linter.js';
+import { inspectDeliveryIntegrity, parseDeliveryIntegrityPolicy } from '../delivery-integrity.js';
+import { evaluateStrictQuality } from '../strict-quality.js';
+import { normalizeFinding, parseSurfacePolicy } from '../disposition.js';
+import { input, readJson, readProfile, readBrief, json } from './io.js';
+function cleanedPath(path) {
+    const extension = extname(path);
+    const stem = extension ? path.slice(0, -extension.length) : path;
+    return `${stem}.cleaned${extension}`;
+}
+function hygieneArguments(args) {
+    const [path, ...options] = args;
+    if (!path)
+        throw new Error('Usage: hyv hygiene draft.md [--fix] [--output=cleaned.md]');
+    let fix = false;
+    let output;
+    for (const option of options) {
+        if (option === '--fix')
+            fix = true;
+        else if (option.startsWith('--output='))
+            output = option.slice('--output='.length).trim();
+        else
+            throw new Error('Usage: hyv hygiene draft.md [--fix] [--output=cleaned.md]');
+    }
+    if (output !== undefined && (!output || !fix))
+        throw new Error('--output requires --fix and a non-empty path.');
+    return { path, fix, ...(output ? { output } : {}) };
+}
+function writeNewFileAtomically(path, text) {
+    const temporaryDirectory = mkdtempSync(join(dirname(resolve(path)), '.hyv-hygiene-'));
+    const temporaryPath = join(temporaryDirectory, 'cleaned');
+    let primaryError;
+    try {
+        writeFileSync(temporaryPath, text, 'utf8');
+        try {
+            linkSync(temporaryPath, path);
+        }
+        catch (error) {
+            const code = error.code;
+            if (!['EPERM', 'ENOTSUP', 'EOPNOTSUPP', 'EXDEV'].includes(code ?? ''))
+                throw error;
+            throw new Error(`Atomic hygiene output is not supported by this filesystem: ${path}`);
+        }
+    }
+    catch (error) {
+        primaryError = error.code === 'EEXIST' ? new Error(`Hygiene output already exists: ${path}`) : error;
+    }
+    try {
+        rmSync(temporaryDirectory, { recursive: true, force: true });
+    }
+    catch (error) {
+        if (!primaryError)
+            console.error(`Warning: output was published, but temporary-file cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (primaryError)
+        throw primaryError;
+}
+export function runDeliveryCheck(args) {
+    const [path, policyPath, ...extra] = args;
+    if (!path || extra.length)
+        throw new Error('Usage: hyv delivery-check <path|-> [policy.json]');
+    const report = inspectDeliveryIntegrity(input(path), policyPath ? parseDeliveryIntegrityPolicy(readJson(policyPath)) : undefined, process.cwd());
+    json(report);
+    return report.passed ? 0 : 2;
+}
+export function runAnalyze(args) {
+    const [draft, profilePath, briefPath] = args;
+    if (!draft || !profilePath)
+        throw new Error('Usage: hyv analyze draft.md profile.json [writing-brief.json]');
+    json(analyze(input(draft), readProfile(profilePath), readBrief(briefPath)));
+    return 0;
+}
+export function runStrictCheck(args) {
+    const [draft, profilePath, ...samplePaths] = args;
+    if (!draft || !profilePath || samplePaths.length < 2)
+        throw new Error('Usage: hyv strict-check draft.md profile-v3.json sample-a.md sample-b.md [sample-c.md ...]');
+    const report = evaluateStrictQuality(input(draft), readProfile(profilePath), samplePaths.map(input));
+    json(report);
+    return report.disposition === 'strict-ready' ? 0 : 2;
+}
+export function runHygiene(args) {
+    const { path, fix, output } = hygieneArguments(args);
+    if (fix && path === '-')
+        throw new Error('hyv hygiene --fix requires a file path so the original can be preserved.');
+    const text = input(path);
+    if (!fix) {
+        json(inspectHygiene(text));
+        return 0;
+    }
+    const outputPath = output ?? cleanedPath(path);
+    if (resolve(outputPath) === resolve(path))
+        throw new Error('Hygiene output must differ from the input path.');
+    const result = cleanHygiene(text);
+    writeNewFileAtomically(outputPath, result.cleaned);
+    json({ ...result.report, changed: result.changed, changes: result.changes, outputPath });
+    return 0;
+}
+export function runInspectHiddenText(args) {
+    const [path, policyPath, ...extra] = args;
+    if (!path || extra.length)
+        throw new Error('Usage: hyv inspect-hidden-text draft.md [policy.json]');
+    json(inspectHiddenText(input(path), policyPath ? parseHiddenTextPolicy(readJson(policyPath)) : undefined));
+    return 0;
+}
+export function runApplyHiddenTextPolicy(args) {
+    const [path, policyPath, output, ...extra] = args;
+    if (!path || !policyPath || !output || extra.length)
+        throw new Error('Usage: hyv apply-hidden-text-policy draft.md policy.json output.md');
+    if (path === '-' || resolve(path) === resolve(output))
+        throw new Error('Hidden-text output must differ from the input path.');
+    const result = applyHiddenTextPolicy(input(path), parseHiddenTextPolicy(readJson(policyPath)));
+    writeNewFileAtomically(output, result.output);
+    json({ ...result, outputPath: output });
+    return 0;
+}
+export function runFinalCheck(args) {
+    const [path, ...options] = args;
+    if (!path || options.length)
+        throw new Error('Usage: hyv final-check <path|->');
+    const result = finalOutputCheck(input(path));
+    if (!result.accepted) {
+        console.error(JSON.stringify(result, null, 2));
+        return 2;
+    }
+    if (result.changed)
+        console.error(JSON.stringify({ changed: true, changes: result.changes }, null, 2));
+    process.stdout.write(result.output);
+    return 0;
+}
+export function runFactLint(args) {
+    const [draftPath, ...options] = args;
+    const sources = [];
+    let metadata;
+    let strict = false;
+    let human = false;
+    if (!draftPath)
+        throw new Error('Usage: hyv fact-lint <draft|-> --source=id:path [--source=id:path] [--metadata=metadata.json] [--strict] [--human]');
+    for (const option of options) {
+        if (option === '--strict') {
+            strict = true;
+            continue;
+        }
+        if (option === '--human') {
+            human = true;
+            continue;
+        }
+        if (option.startsWith('--source=')) {
+            const value = option.slice('--source='.length);
+            const separator = value.indexOf(':');
+            const id = value.slice(0, separator).trim();
+            const path = value.slice(separator + 1);
+            if (separator < 1 || !id || !path)
+                throw new Error('Sources must use --source=id:path.');
+            sources.push({ id, text: input(path) });
+            continue;
+        }
+        if (option.startsWith('--metadata=')) {
+            metadata = JSON.parse(input(option.slice('--metadata='.length)));
+            continue;
+        }
+        throw new Error('Usage: hyv fact-lint <draft|-> --source=id:path [--source=id:path] [--metadata=metadata.json] [--strict] [--human]');
+    }
+    const report = lintFacts({ sources, draft: input(draftPath), metadata });
+    if (human)
+        console.log(formatFactLintReport(report));
+    else
+        json(report);
+    return strict && report.findings.some((item) => item.severity === 'error') ? 2 : 0;
+}
+export function runLogicLint(args) {
+    const [draftPath, briefPath, ...extra] = args;
+    if (!draftPath || extra.length)
+        throw new Error('Usage: hyv logic-lint <draft|-> [writing-brief.json]');
+    const report = lintLogic(input(draftPath), readBrief(briefPath));
+    json(report);
+    return report.passed ? 0 : 2;
+}
+export function runBatchAnalyze(args) {
+    if (args.length < 2)
+        throw new Error('Usage: hyv batch-analyze draft-a.md draft-b.md [draft-c.md]');
+    json(analyzeBatch(args.map(input)));
+    return 0;
+}
+export function runVerify(args) {
+    const [original, candidate, profilePath, briefPath] = args;
+    if (!original || !candidate || !profilePath)
+        throw new Error('Usage: hyv verify original.md candidate.md profile.json [writing-brief.json]');
+    const profile = readProfile(profilePath);
+    const originalText = input(original);
+    const candidateText = input(candidate);
+    const result = verify(originalText, candidateText, profile, readBrief(briefPath));
+    json(result);
+    return result.passed ? 0 : 2;
+}
+export function runVerifySpec(args) {
+    const [original, candidate, profilePath, specPath, briefPath] = args;
+    if (!original || !candidate || !profilePath || !specPath)
+        throw new Error('Usage: hyv verify-spec original.md candidate.md profile.json copy-spec.json [writing-brief.json]');
+    const profile = readProfile(profilePath);
+    const candidateText = input(candidate);
+    const result = verifyWithCopySpec(input(original), candidateText, profile, parseCopySpec(JSON.parse(input(specPath))), readBrief(briefPath));
+    json(result);
+    return result.passed ? 0 : 2;
+}
+export function runPatterns() {
+    json({ version: RULESET_VERSION, rules: serializedRules() });
+    return 0;
+}
+export function runDispositions(args) {
+    const [draft, profilePath, briefPath, surfacePolicyPath] = args;
+    if (!draft || !profilePath)
+        throw new Error('Usage: hyv dispositions draft.md profile.json [writing-brief.json]');
+    const report = analyze(input(draft), readProfile(profilePath), readBrief(briefPath));
+    const policy = surfacePolicyPath ? parseSurfacePolicy(readJson(surfacePolicyPath)) : undefined;
+    json({ version: '1', findings: [report.voiceDna, report.aiEditor, report.editorial].flatMap((engine) => engine?.findings.map((finding) => normalizeFinding(finding, policy)) ?? []) });
+    return 0;
+}

package/dist/cli/io.js

@@ -0,0 +1,141 @@
+import { closeSync, constants, fstatSync, openSync, readFileSync, readSync, writeFileSync } from 'node:fs';
+import { parseCopySpec } from '../copy-spec.js';
+import { parseWritingBrief } from '../editorial-packs.js';
+import { parseProfile } from '../profile.js';
+import { canonicalJson, parseCanonicalJson } from '../canonical-json.js';
+import { MAX_JSON_BYTES } from '../internal.js';
+export function input(path) {
+    return path === '-' ? readFileSync(0, 'utf8') : readFileSync(path, 'utf8');
+}
+function parseBoundedJson(text) {
+    if (Buffer.byteLength(text, 'utf8') > MAX_JSON_BYTES)
+        throw new Error('JSON input exceeds the byte limit.');
+    const value = JSON.parse(text);
+    canonicalJson(value);
+    return value;
+}
+function readBoundedDescriptor(descriptor) {
+    const chunks = [];
+    let size = 0;
+    while (size <= MAX_JSON_BYTES) {
+        const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, MAX_JSON_BYTES + 1 - size));
+        const count = readSync(descriptor, chunk, 0, chunk.length, null);
+        if (!count)
+            break;
+        chunks.push(chunk.subarray(0, count));
+        size += count;
+    }
+    if (size > MAX_JSON_BYTES)
+        throw new Error('JSON input exceeds the byte limit.');
+    return Buffer.concat(chunks, size).toString('utf8');
+}
+function withDescriptor(path, flags, read, openError) {
+    let descriptor;
+    try {
+        descriptor = openSync(path, flags);
+    }
+    catch (error) {
+        throw openError ? new Error(openError) : error;
+    }
+    try {
+        return read(descriptor);
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+export function readJson(path) {
+    return path === '-'
+        ? parseBoundedJson(readBoundedDescriptor(0))
+        : withDescriptor(path, constants.O_RDONLY, (descriptor) => parseBoundedJson(readBoundedDescriptor(descriptor)));
+}
+function readCapabilityDescriptor(descriptor) {
+    try {
+        const before = fstatSync(descriptor);
+        if (!before.isFile() || before.uid !== process.geteuid?.() || (before.mode & 0o077) !== 0 || before.nlink !== 1 || before.size > MAX_JSON_BYTES) {
+            throw new Error('Capability file is unavailable or unsafe.');
+        }
+        const raw = readBoundedDescriptor(descriptor);
+        const after = fstatSync(descriptor);
+        if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs) {
+            throw new Error('Capability file is unavailable or unsafe.');
+        }
+        return raw;
+    }
+    catch {
+        throw new Error('Capability file is unavailable or unsafe.');
+    }
+}
+export function capabilityArguments(args) {
+    const values = [];
+    let source;
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === '--capability-stdin') {
+            if (source)
+                throw new Error('Choose one capability source.');
+            source = { kind: 'stdin' };
+        }
+        else if (argument === '--capability-file') {
+            const path = args[++index];
+            if (source || !path || path.startsWith('--capability-'))
+                throw new Error('Choose one capability source.');
+            source = { kind: 'file', path };
+        }
+        else {
+            values.push(argument);
+        }
+    }
+    if (!source)
+        return { values };
+    if (source.kind === 'stdin' && values.includes('-'))
+        throw new Error('Capability stdin cannot be combined with another stdin input.');
+    const raw = source.kind === 'stdin'
+        ? readBoundedDescriptor(0)
+        : withDescriptor(source.path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0), readCapabilityDescriptor, 'Capability file is unavailable or unsafe.');
+    if (Buffer.byteLength(raw, 'utf8') > MAX_JSON_BYTES)
+        throw new Error('JSON input exceeds the byte limit.');
+    return { values, capability: parseCanonicalJson(Buffer.from(raw, 'utf8')) };
+}
+export function readProfile(path) {
+    return parseProfile(JSON.parse(input(path)));
+}
+export function readBrief(path) {
+    return path ? parseWritingBrief(JSON.parse(input(path))) : undefined;
+}
+function tryParse(parse, value) {
+    try {
+        return parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function prepareContext(paths) {
+    let copySpec;
+    let writingBrief;
+    for (const path of paths) {
+        const value = JSON.parse(input(path));
+        const parsedCopySpec = tryParse(parseCopySpec, value);
+        if (parsedCopySpec) {
+            if (copySpec)
+                throw new Error('Prepare-rewrite accepts at most one CopySpec.');
+            copySpec = parsedCopySpec;
+            continue;
+        }
+        const parsedBrief = tryParse(parseWritingBrief, value);
+        if (!parsedBrief)
+            throw new Error(`Expected a valid CopySpec or WritingBrief at ${path}.`);
+        if (writingBrief)
+            throw new Error('Prepare-rewrite accepts at most one WritingBrief.');
+        writingBrief = parsedBrief;
+    }
+    return { copySpec, writingBrief };
+}
+export function json(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+export function canonical(value) { process.stdout.write(`${canonicalJson(value)}\n`); }
+export function writeJson(path, value) {
+    writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
+}

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;
+}