@aiwg/cli 2026.9.3 → 2026.9.5

package/dist/src/writing/voice-revision.js

@@ -0,0 +1,201 @@
+import { createHash } from 'node:crypto';
+import { assessWritingFidelity } from './fidelity.js';
+import { parseWritingBrief } from './writing-brief.js';
+import { parseWriterProfile } from './writer-profile.js';
+const hash = (text) => createHash('sha256').update(text).digest('hex');
+function validateEdits(source, edits) {
+    const sorted = structuredClone(edits).sort((a, b) => a.start - b.start || a.end - b.end);
+    const boundary = (at) => Number.isSafeInteger(at) && at >= 0 && at <= source.length && !(at > 0 && at < source.length && /[\uD800-\uDBFF]/.test(source[at - 1]) && /[\uDC00-\uDFFF]/.test(source[at]));
+    if (new Set(sorted.map(e => e.id)).size !== sorted.length)
+        throw new Error('Duplicate revision edit IDs');
+    for (let i = 0; i < sorted.length; i++) {
+        const e = sorted[i];
+        if (typeof e.id !== 'string' || !e.id || !boundary(e.start) || !boundary(e.end) || e.start > e.end || typeof e.expected !== 'string' || source.slice(e.start, e.end) !== e.expected || typeof e.replacement !== 'string' || !e.reason?.trim())
+            throw new Error('Invalid or stale revision edit');
+        if (i && (e.start < sorted[i - 1].end || e.start === sorted[i - 1].start))
+            throw new Error('Overlapping revision edits require review');
+    }
+    return sorted;
+}
+function applyEdits(source, edits) {
+    let output = source;
+    for (const e of [...validateEdits(source, edits)].reverse())
+        output = output.slice(0, e.start) + e.replacement + output.slice(e.end);
+    return output;
+}
+export function createRevisionReview(original, edits, origin = 'human') {
+    if (origin !== 'human' && origin !== 'generated')
+        throw new Error('Invalid correction origin');
+    return { original, sourceHash: hash(original), edits: validateEdits(original, edits), candidate: applyEdits(original, edits), origin };
+}
+export function acceptRevisionEdits(review, decision) {
+    const frozen = createRevisionReview(review.original, review.edits, review.origin);
+    if (decision.sourceHash !== frozen.sourceHash || review.sourceHash !== frozen.sourceHash || review.candidate !== frozen.candidate)
+        throw new Error('Stale revision source or candidate');
+    const ids = [...decision.acceptedIds, ...decision.rejectedIds];
+    if (!decision.actor.trim() || new Set(ids).size !== ids.length || ids.some(id => !frozen.edits.some(e => e.id === id)) || ids.length !== frozen.edits.length)
+        throw new Error('Every edit requires exactly one explicit human decision');
+    const output = applyEdits(frozen.original, frozen.edits.filter(e => decision.acceptedIds.includes(e.id)));
+    return { ...frozen, actor: decision.actor, acceptedIds: [...decision.acceptedIds], rejectedIds: [...decision.rejectedIds], output, outputHash: hash(output), approval: 'explicit-human' };
+}
+export function undoRevisionReview(review) {
+    if (hash(review.original) !== review.sourceHash)
+        throw new Error('Stale revision source');
+    return review.original;
+}
+class RevisionStop extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+    }
+}
+/** Bounded automatic assistance; artifacts survive cancellation and no judge is required for human review. */
+export async function runVoiceRevision(original, input) {
+    const options = { ...input, ...(input.brief ? { brief: parseWritingBrief(input.brief) } : {}) };
+    const maxPasses = options.maxPasses ?? 2;
+    if (!['preserve', 'light', 'substantive'].includes(options.strength) || !Number.isSafeInteger(maxPasses) || maxPasses < 0 || maxPasses > 100 || !Number.isSafeInteger(options.tokenBudget) || options.tokenBudget < 0 || !Number.isSafeInteger(options.perCallTokenReservation) || options.perCallTokenReservation < 1 || !Number.isFinite(options.timeBudgetMs) || options.timeBudgetMs <= 0)
+        throw new Error('Invalid revision limits');
+    const started = performance.now();
+    const result = { original, originalHash: hash(original), receivedProposals: [], candidates: [], best: original, bestHash: hash(original), receipt: {
+            strength: options.strength, passes: 0, stopReason: 'pass-limit', elapsedMs: 0, tokenBudget: options.tokenBudget, chargedTokens: 0, reportedTokens: 0, reservedTokens: 0, reportedCostUsd: null, costsComplete: true, calls: [], authorAcceptance: 'not-requested', qualityClaim: 'not-qualified',
+        } };
+    const remainingTime = () => options.timeBudgetMs - (performance.now() - started);
+    const call = async (phase, action) => {
+        if (options.signal?.aborted)
+            throw new RevisionStop('cancelled');
+        if (remainingTime() <= 0)
+            throw new RevisionStop('time-budget');
+        const reservation = options.perCallTokenReservation;
+        if (result.receipt.chargedTokens + reservation > options.tokenBudget)
+            throw new RevisionStop('token-budget');
+        const entry = { phase, measurement: 'reserved-upper-bound', chargedTokens: reservation };
+        result.receipt.calls.push(entry);
+        result.receipt.chargedTokens += reservation;
+        result.receipt.reservedTokens += reservation;
+        const controller = new AbortController();
+        let timer;
+        let abort;
+        try {
+            const context = { original, current: result.best, strength: options.strength, signal: controller.signal, maxTokens: reservation, ...(options.brief ? { brief: structuredClone(options.brief) } : {}) };
+            const response = await Promise.race([Promise.resolve().then(() => action(context)), new Promise((_, reject) => {
+                    timer = setTimeout(() => { controller.abort(); reject(new RevisionStop('time-budget')); }, Math.max(1, remainingTime()));
+                    abort = () => { controller.abort(); reject(new RevisionStop('cancelled')); };
+                    options.signal?.addEventListener('abort', abort, { once: true });
+                })]);
+            if (!response || !('value' in response))
+                throw new RevisionStop('invalid-callback');
+            if (response.usage) {
+                const u = response.usage;
+                if (!Number.isSafeInteger(u.tokens) || u.tokens < 0 || !u.model?.trim() || !u.provider?.trim() || (u.costUsd !== undefined && (!Number.isFinite(u.costUsd) || u.costUsd < 0)))
+                    throw new RevisionStop('invalid-usage');
+                entry.measurement = 'reported';
+                entry.chargedTokens = u.tokens;
+                entry.usage = structuredClone(u);
+                result.receipt.chargedTokens += u.tokens - reservation;
+                result.receipt.reservedTokens -= reservation;
+                result.receipt.reportedTokens += u.tokens;
+                if (u.costUsd !== undefined)
+                    result.receipt.reportedCostUsd = (result.receipt.reportedCostUsd ?? 0) + u.costUsd;
+                if (u.tokens > reservation)
+                    throw new RevisionStop('provider-budget-overrun');
+            }
+            if (options.signal?.aborted)
+                throw new RevisionStop('cancelled');
+            if (remainingTime() <= 0)
+                throw new RevisionStop('time-budget');
+            return structuredClone(response.value);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            if (abort)
+                options.signal?.removeEventListener('abort', abort);
+            if (entry.usage?.costUsd === undefined)
+                result.receipt.costsComplete = false;
+        }
+    };
+    try {
+        if (options.strength === 'preserve')
+            throw new RevisionStop('preserve');
+        if (!options.revise)
+            throw new RevisionStop('human-review');
+        for (let pass = 0; pass < maxPasses; pass++) {
+            const critique = options.critique ? await call('critique', options.critique) : [];
+            if (!Array.isArray(critique) || critique.some(c => !Number.isSafeInteger(c.start) || !Number.isSafeInteger(c.end) || c.start < 0 || c.end < c.start || c.end > result.best.length || !c.reason?.trim()))
+                throw new RevisionStop('invalid-critique');
+            const proposal = await call('revise', context => options.revise({ ...context, critique: structuredClone(critique) }));
+            result.receivedProposals.push({ parentHash: result.bestHash, payload: structuredClone(proposal) });
+            const review = createRevisionReview(result.best, proposal.edits, 'generated');
+            if (review.candidate !== proposal.candidate)
+                throw new RevisionStop('candidate-edit-mismatch');
+            result.receipt.passes++;
+            const candidate = { id: `candidate-${pass + 1}`, parentHash: result.bestHash, content: proposal.candidate, contentHash: hash(proposal.candidate), edits: review.edits, critique: structuredClone(critique), fidelity: 'uncertain', preference: 'unreviewed', retained: false };
+            result.candidates.push(candidate);
+            if (options.strength === 'light' && review.edits.some(e => /\r|\n/.test(e.expected + e.replacement) || !critique.some(c => c.start <= e.start && c.end >= e.end)))
+                throw new RevisionStop('strength-limit');
+            const assessment = assessWritingFidelity(original, proposal.candidate, options.brief);
+            candidate.fidelity = assessment.outcome;
+            candidate.fidelityAssessment = assessment;
+            if (assessment.outcome === 'fail')
+                throw new RevisionStop('fidelity-failure');
+            if (proposal.candidate === result.best) {
+                candidate.preference = 'same';
+                throw new RevisionStop('no-improvement');
+            }
+            if (!options.reviewCandidate)
+                throw new RevisionStop('human-review');
+            const judged = await call('review', context => options.reviewCandidate({ ...context, candidate: proposal.candidate }));
+            if (!['pass', 'fail', 'uncertain'].includes(judged.fidelity) || !['better', 'same', 'worse'].includes(judged.preference) || !judged.rationale?.trim())
+                throw new RevisionStop('invalid-review');
+            candidate.fidelity = judged.fidelity;
+            candidate.preference = judged.preference;
+            candidate.review = structuredClone(judged);
+            if (judged.fidelity !== 'pass')
+                throw new RevisionStop(judged.fidelity === 'fail' ? 'fidelity-failure' : 'fidelity-review');
+            if (judged.preference !== 'better')
+                throw new RevisionStop(judged.preference === 'same' ? 'no-improvement' : 'worse-candidate');
+            for (const previous of result.candidates)
+                previous.retained = false;
+            candidate.retained = true;
+            result.best = candidate.content;
+            result.bestHash = candidate.contentHash;
+        }
+    }
+    catch (error) {
+        result.receipt.stopReason = error instanceof RevisionStop ? error.reason : 'callback-or-validation-error';
+    }
+    result.receipt.elapsedMs = performance.now() - started;
+    return result;
+}
+/** Only human-origin corrections explicitly accepted by a person can propose expression overrides. */
+export function proposeWriterLearning(profile, accepted, overrides) {
+    const p = parseWriterProfile(profile);
+    if (accepted.origin !== 'human' || accepted.approval !== 'explicit-human' || accepted.acceptedIds.length === 0 || accepted.output === accepted.original || overrides.length === 0)
+        throw new Error('Learning requires explicitly approved human corrections');
+    const checked = acceptRevisionEdits(accepted, accepted);
+    if (checked.output !== accepted.output || checked.outputHash !== accepted.outputHash)
+        throw new Error('Stale human correction artifact');
+    const validated = parseWriterProfile({ ...p, overrides: [...p.overrides, ...overrides] });
+    return { schemaVersion: 1, profileId: p.id, expectedRevision: p.revision, profileHash: hash(JSON.stringify(p)), overrides: validated.overrides.slice(p.overrides.length), provenance: { actor: accepted.actor, sourceHash: accepted.sourceHash, outputHash: accepted.outputHash, correctionIds: [...accepted.acceptedIds] } };
+}
+function advanceProfile(p) { const parts = p.version.split('.').map(Number); parts[2]++; p.version = parts.join('.'); p.revision++; p.cacheEpoch++; }
+export function acceptWriterLearning(profile, proposal, decision) {
+    const p = parseWriterProfile(profile);
+    if (!decision.actor.trim() || proposal.schemaVersion !== 1 || p.id !== proposal.profileId || decision.expectedRevision !== p.revision || proposal.expectedRevision !== p.revision || proposal.profileHash !== hash(JSON.stringify(p)))
+        throw new Error('Stale profile update or missing explicit acceptance');
+    const previousOverrides = structuredClone(p.overrides);
+    p.overrides.push(...structuredClone(proposal.overrides));
+    advanceProfile(p);
+    const updated = parseWriterProfile(p);
+    return { profile: updated, undo: { acceptedBy: decision.actor, profileId: updated.id, afterHash: hash(JSON.stringify(updated)), previousOverrides, provenance: structuredClone(proposal.provenance) } };
+}
+export function undoWriterLearning(profile, undo) {
+    const p = parseWriterProfile(profile);
+    if (p.id !== undo.profileId || hash(JSON.stringify(p)) !== undo.afterHash)
+        throw new Error('Stale profile undo');
+    p.overrides = structuredClone(undo.previousOverrides);
+    advanceProfile(p);
+    return parseWriterProfile(p);
+}
+//# sourceMappingURL=voice-revision.js.map

package/dist/src/writing/writer-migration.js

@@ -0,0 +1,216 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { isAbsolute, resolve, join } from 'node:path';
+import { z } from 'zod';
+import { importLegacyWriterProfile } from './writer-profile-legacy.js';
+import { parseWriterProfile } from './writer-profile.js';
+import { WriterProfileStore } from './writer-profile-store.js';
+const digest = z.string().regex(/^[a-f0-9]{64}$/);
+const profileId = z.string().regex(/^[a-z0-9][a-z0-9.-]{0,79}$/).refine(value => !value.includes('..'));
+const hash = (text) => createHash('sha256').update(text, 'utf8').digest('hex');
+function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, child]) => child !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, child]) => [key, canonicalize(child)]));
+    }
+    return value;
+}
+const requestSchema = z.object({
+    cwd: z.string().min(1),
+    sourcePath: z.string().min(1),
+    format: z.enum(['yaml', 'json']),
+    scope: z.enum(['project', 'user']).default('project'),
+    userConfigDir: z.string().min(1).optional(),
+    profile: z.object({
+        id: profileId,
+        name: z.string().min(1).max(200),
+        version: z.string().regex(/^\d+\.\d+\.\d+$/).default('1.0.0'),
+        provenance: z.object({ source: z.string().min(1).max(2000), license: z.string().min(1).max(200) }).strict(),
+    }).strict(),
+}).strict();
+const planSchema = z.object({
+    schemaVersion: z.literal('aiwg.writer-migration-plan.v1'),
+    id: z.string().regex(/^wm-[a-f0-9]{24}$/),
+    planSha256: digest,
+    createdAt: z.string().datetime(),
+    dryRun: z.literal(true),
+    cwd: z.string().min(1),
+    source: z.object({ path: z.string().min(1), format: z.enum(['yaml', 'json']), sha256: digest, bytes: z.number().int().nonnegative(), legacyKind: z.string().min(1).max(80) }).strict(),
+    target: z.object({
+        scope: z.enum(['project', 'user']),
+        profileId,
+        userConfigDir: z.string().min(1).optional(),
+        existingProfile: z.object({ revision: z.number().int().positive(), sha256: digest }).strict().nullable(),
+        activatesProfile: z.literal(false),
+    }).strict(),
+    actions: z.array(z.string().min(1).max(200)).min(1),
+    warnings: z.array(z.string().min(1).max(400)),
+    profileTemplate: z.unknown(),
+}).strict();
+function planDigest(plan) {
+    return hash(JSON.stringify(canonicalize(plan)));
+}
+function profileDigest(profile) {
+    return hash(JSON.stringify(canonicalize(profile)));
+}
+function resolveSourcePath(cwd, sourcePath) {
+    return isAbsolute(sourcePath) ? sourcePath : resolve(cwd, sourcePath);
+}
+function validateMigrationPlan(input) {
+    const parsed = planSchema.parse(input);
+    const profile = parseWriterProfile(parsed.profileTemplate);
+    const { planSha256, ...body } = parsed;
+    if (planDigest({ ...body, profileTemplate: profile }) !== planSha256)
+        throw new Error('Writer migration plan integrity mismatch');
+    if (profile.id !== parsed.target.profileId)
+        throw new Error('Writer migration plan target does not match profile template');
+    if (!profile.legacy || profile.legacy.sha256 !== parsed.source.sha256 || profile.legacy.format !== parsed.source.format || profile.legacy.kind !== parsed.source.legacyKind) {
+        throw new Error('Writer migration plan source does not match profile template legacy attachment');
+    }
+    return { ...parsed, profileTemplate: profile };
+}
+export async function planWriterProfileMigration(input) {
+    const request = requestSchema.parse(input);
+    const sourcePath = resolveSourcePath(request.cwd, request.sourcePath);
+    const raw = await readFile(sourcePath, 'utf8');
+    const legacy = importLegacyWriterProfile(raw, request.format);
+    const profile = parseWriterProfile({
+        schemaVersion: 1,
+        id: request.profile.id,
+        version: request.profile.version,
+        name: request.profile.name,
+        provenance: request.profile.provenance,
+        samples: [],
+        preferences: [],
+        legacy,
+    });
+    const store = new WriterProfileStore({ cwd: request.cwd, scope: request.scope, userConfigDir: request.userConfigDir });
+    let existingProfile = null;
+    try {
+        const current = await store.read(request.profile.id);
+        existingProfile = { revision: current.revision, sha256: profileDigest(current) };
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const body = {
+        schemaVersion: 'aiwg.writer-migration-plan.v1',
+        id: `wm-${hash(`${sourcePath}\0${legacy.sha256}\0${request.profile.id}`).slice(0, 24)}`,
+        createdAt: new Date().toISOString(),
+        dryRun: true,
+        cwd: request.cwd,
+        source: { path: sourcePath, format: request.format, sha256: legacy.sha256, bytes: Buffer.byteLength(raw, 'utf8'), legacyKind: legacy.kind },
+        target: { scope: request.scope, profileId: request.profile.id, ...(request.userConfigDir ? { userConfigDir: request.userConfigDir } : {}), existingProfile, activatesProfile: false },
+        actions: ['validate legacy adapter payload', 'write private managed backup', 'create writer sidecar profile', 'leave output-mode activation unchanged'],
+        warnings: [
+            'Migration preserves legacy numeric fields and raw bytes; it does not infer a replacement score.',
+            'External shared exports may still exist outside this local profile store and require separate operator review.',
+        ],
+        profileTemplate: profile,
+    };
+    return { ...body, planSha256: planDigest(body) };
+}
+async function writePrivateBackup(store, profile, backup) {
+    const directory = store.managedMigrationBackupDirectory(profile);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const destination = join(directory, `${backup.id}.${randomUUID()}.json`);
+    const payload = JSON.stringify(backup, null, 2) + '\n';
+    const temporary = `${destination}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, payload, { mode: 0o600, flag: 'wx' });
+        await rename(temporary, destination);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return { path: destination, sha256: hash(payload) };
+}
+export async function applyWriterProfileMigration(input) {
+    const plan = validateMigrationPlan(input);
+    const raw = await readFile(plan.source.path, 'utf8');
+    const legacy = importLegacyWriterProfile(raw, plan.source.format);
+    if (legacy.sha256 !== plan.source.sha256 || legacy.kind !== plan.source.legacyKind || Buffer.byteLength(raw, 'utf8') !== plan.source.bytes) {
+        throw new Error('Legacy profile changed after migration plan was created');
+    }
+    const store = new WriterProfileStore({ cwd: plan.cwd, scope: plan.target.scope, userConfigDir: plan.target.userConfigDir });
+    let previous = null;
+    try {
+        previous = await store.read(plan.target.profileId);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const currentState = previous ? { revision: previous.revision, sha256: profileDigest(previous) } : null;
+    if (JSON.stringify(currentState) !== JSON.stringify(plan.target.existingProfile))
+        throw new Error('Writer profile changed after migration plan was created');
+    const backup = {
+        schemaVersion: 'aiwg.writer-migration-backup.v1',
+        id: plan.id,
+        source: { path: plan.source.path, format: plan.source.format, sha256: plan.source.sha256, rawBase64: Buffer.from(raw, 'utf8').toString('base64') },
+        previousProfile: previous ? { sha256: profileDigest(previous), json: previous } : null,
+    };
+    const backupRecord = await writePrivateBackup(store, plan.target.profileId, backup);
+    const revisionBefore = previous?.revision ?? 0;
+    let saved;
+    try {
+        saved = await store.save(plan.profileTemplate, revisionBefore, { preserveMigrationBackups: true });
+    }
+    catch (error) {
+        await rm(backupRecord.path, { force: true });
+        throw error;
+    }
+    return {
+        schemaVersion: 'aiwg.writer-migration-apply.v1',
+        id: plan.id,
+        appliedAt: new Date().toISOString(),
+        cwd: plan.cwd,
+        sourceSha256: plan.source.sha256,
+        backupPath: backupRecord.path,
+        backupSha256: backupRecord.sha256,
+        profileId: saved.id,
+        scope: plan.target.scope,
+        ...(plan.target.userConfigDir ? { userConfigDir: plan.target.userConfigDir } : {}),
+        profileRevisionBefore: revisionBefore,
+        profileRevisionAfter: saved.revision,
+        createdProfileSha256: profileDigest(saved),
+        activatedProfile: false,
+    };
+}
+export async function rollbackWriterProfileMigration(result, options = {}) {
+    const cwd = options.cwd ?? result.cwd;
+    const store = new WriterProfileStore({ cwd, scope: options.scope ?? result.scope, userConfigDir: options.userConfigDir ?? result.userConfigDir });
+    const allowedDirectory = store.managedMigrationBackupDirectory(result.profileId);
+    if (!resolve(result.backupPath).startsWith(`${resolve(allowedDirectory)}/`))
+        throw new Error('Writer migration backup path is outside the managed backup directory');
+    const current = await store.read(result.profileId);
+    if (current.revision !== result.profileRevisionAfter || profileDigest(current) !== result.createdProfileSha256)
+        throw new Error('Writer profile changed after migration; rollback refused');
+    const payload = await readFile(result.backupPath, 'utf8');
+    if (hash(payload) !== result.backupSha256)
+        throw new Error('Writer migration backup integrity mismatch');
+    let backup;
+    try {
+        backup = JSON.parse(payload);
+    }
+    catch {
+        throw new Error('Writer migration backup is corrupt or not JSON');
+    }
+    if (backup.schemaVersion !== 'aiwg.writer-migration-backup.v1' || backup.id !== result.id || backup.source.sha256 !== result.sourceSha256)
+        throw new Error('Writer migration backup does not match apply result');
+    if (backup.previousProfile) {
+        const previous = parseWriterProfile(backup.previousProfile.json);
+        if (profileDigest(previous) !== backup.previousProfile.sha256)
+            throw new Error('Previous writer profile backup integrity mismatch');
+        await store.save(previous, current.revision);
+        return 'restored';
+    }
+    await store.delete(result.profileId, current.revision);
+    return 'removed';
+}
+//# sourceMappingURL=writer-migration.js.map

package/dist/src/writing/writer-profile-legacy.js

@@ -0,0 +1,145 @@
+import { createHash } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+import { parseDocument } from 'yaml';
+const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const nonempty = (value) => typeof value === 'string' && value.trim().length > 0;
+const finite = (value) => typeof value === 'number' && Number.isFinite(value);
+const bounded = (value, max = 1) => finite(value) && value >= 0 && value <= max;
+const strings = (value) => Array.isArray(value) && value.every(item => typeof item === 'string');
+const fail = () => { throw new Error('Invalid or unsupported legacy writer profile. Source text is omitted from diagnostics.'); };
+/** Decode UTF-8 without dropping a BOM or silently replacing invalid source bytes. */
+function sourceText(raw) {
+    if (typeof raw === 'string') {
+        if (Buffer.from(raw, 'utf8').toString('utf8') !== raw)
+            fail();
+        return raw;
+    }
+    if (!(raw instanceof Uint8Array))
+        fail();
+    const bytes = Buffer.from(raw);
+    const text = bytes.toString('utf8');
+    if (!Buffer.from(text, 'utf8').equals(bytes))
+        fail();
+    return text;
+}
+function parseSource(raw, format) {
+    try {
+        if (format === 'json')
+            return JSON.parse(raw.replace(/^\uFEFF/, ''));
+        if (format !== 'yaml')
+            fail();
+        const document = parseDocument(raw, { uniqueKeys: true, strict: true });
+        if (document.errors.length || document.warnings.length)
+            fail();
+        const payload = document.toJS({ maxAliasCount: 100 });
+        // Sidecars serialize as JSON: reject cyclic aliases, non-finite numbers and
+        // other YAML values that would silently change on private export.
+        if (!isDeepStrictEqual(payload, JSON.parse(JSON.stringify(payload))))
+            fail();
+        return payload;
+    }
+    catch {
+        // Parser messages may quote private samples, filenames or instruction text.
+        return fail();
+    }
+}
+function isCalibration(value) {
+    if (!record(value) || !nonempty(value.voice) || !bounded(value.detectionConfidence) || !record(value.characteristics) || !Array.isArray(value.markers))
+        return false;
+    const c = value.characteristics;
+    if (!['formality', 'technicality', 'assertiveness', 'complexity'].every(key => bounded(c[key])))
+        return false;
+    const lengths = c.sentenceLength;
+    if (!record(lengths) || !['avg', 'min', 'max', 'variance'].every(key => finite(lengths[key]) && lengths[key] >= 0))
+        return false;
+    if (!['basic', 'intermediate', 'advanced', 'expert'].includes(String(c.vocabularyLevel)) || !bounded(c.firstPersonUsage, 100) || !bounded(c.passiveVoiceRatio, 100))
+        return false;
+    return value.markers.every(marker => record(marker)
+        && ['vocabulary', 'structure', 'tone', 'perspective'].includes(String(marker.type))
+        && typeof marker.indicator === 'string' && bounded(marker.weight) && strings(marker.examples));
+}
+function isAnalyzer(value) {
+    if (!['academic', 'technical', 'executive', 'casual', 'mixed'].includes(String(value.primaryVoice)) || !bounded(value.confidence, 100) || !record(value.characteristics) || !record(value.metadata) || !Array.isArray(value.markers))
+        return false;
+    const characteristics = value.characteristics;
+    if (!['academic', 'technical', 'executive', 'casual'].every(key => finite(characteristics[key]) && characteristics[key] >= 0))
+        return false;
+    const metadata = value.metadata;
+    return ['wordCount', 'sentenceCount', 'averageSentenceLength'].every(key => finite(metadata[key]) && metadata[key] >= 0)
+        && ['first-person', 'third-person', 'neutral'].includes(String(value.perspective))
+        && ['formal', 'conversational', 'enthusiastic', 'matter-of-fact'].includes(String(value.tone))
+        && value.markers.every(marker => record(marker)
+            && ['academic', 'technical', 'executive', 'casual'].includes(String(marker.type))
+            && typeof marker.text === 'string' && Number.isInteger(marker.position) && marker.position >= 0
+            && ['strong', 'moderate', 'weak'].includes(String(marker.strength)));
+}
+/** Recognize producer families without rewriting their incompatible legacy fields. */
+function classify(payload) {
+    if (Array.isArray(payload)) {
+        if (payload.length > 0 && payload.every(isCalibration))
+            return 'ts-calibration';
+        return fail();
+    }
+    if (!record(payload))
+        return fail();
+    if ('profiles' in payload) {
+        if (Array.isArray(payload.profiles) && payload.profiles.length > 0 && payload.profiles.every(isCalibration))
+            return 'ts-calibration';
+        return fail();
+    }
+    if ('primaryVoice' in payload)
+        return isAnalyzer(payload) ? 'ts-analyzer' : fail();
+    if ('voice' in payload)
+        return isCalibration(payload) ? 'ts-calibration' : fail();
+    if (!nonempty(payload.name) || !nonempty(payload.version) || typeof payload.description !== 'string' || !record(payload.tone))
+        return fail();
+    for (const key of ['formality', 'confidence', 'warmth', 'energy', 'complexity']) {
+        if (key in payload.tone && !bounded(payload.tone[key]))
+            return fail();
+    }
+    const producers = ['generated_from', 'analysis_source', 'blend_sources'].filter(key => key in payload);
+    if (producers.length > 1)
+        return fail();
+    if ('generated_from' in payload) {
+        if (typeof payload.generated_from !== 'string' || typeof payload.detected_domain !== 'string')
+            return fail();
+        return 'python-generated';
+    }
+    if ('analysis_source' in payload) {
+        const source = payload.analysis_source;
+        if (!record(source) || !finite(source.sample_size) || source.sample_size < 0 || !bounded(source.confidence) || !record(payload.extracted_metrics))
+            return fail();
+        return 'python-analyzed';
+    }
+    if ('blend_sources' in payload) {
+        if (!Array.isArray(payload.blend_sources) || !payload.blend_sources.length || !payload.blend_sources.every(source => record(source) && nonempty(source.name) && finite(source.weight)))
+            return fail();
+        return 'python-blended';
+    }
+    return 'addon-template';
+}
+/**
+ * Explicit, lossless import. No preferences, samples, identities or instructions
+ * are inferred. Keep this attachment private unless separately reviewed: legacy
+ * examples and unknown fields may contain personal text or secrets.
+ */
+export function importLegacyWriterProfile(raw, format) {
+    const text = sourceText(raw);
+    const payload = parseSource(text, format);
+    const kind = classify(payload);
+    return { format, kind, raw: text, sha256: createHash('sha256').update(text, 'utf8').digest('hex'), payload };
+}
+/** Reject stale/tampered payloads and metadata without quoting source content. */
+export function validateLegacyWriterProfile(attachment) {
+    if (!record(attachment) || typeof attachment.raw !== 'string')
+        return fail();
+    const imported = importLegacyWriterProfile(attachment.raw, attachment.format);
+    if (attachment.sha256 !== imported.sha256 || attachment.kind !== imported.kind || !isDeepStrictEqual(attachment.payload, imported.payload))
+        return fail();
+    return imported;
+}
+/** Return original UTF-8 text, including whitespace, comments, BOM and newlines. */
+export function exportLegacyWriterProfile(attachment) {
+    return validateLegacyWriterProfile(attachment).raw;
+}
+//# sourceMappingURL=writer-profile-legacy.js.map