@aiwg/cli 2026.9.4 → 2026.9.6

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

@@ -0,0 +1,117 @@
+import { mkdir, readFile, writeFile, rename, rm, readdir, lstat } from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { resolveUserConfigDir } from '../config/user-config-dir.mjs';
+import { parseWriterProfile } from './writer-profile.js';
+/** Explicit scopes never fall through to a profile in another scope. */
+export class WriterProfileStore {
+    directory;
+    constructor(options) {
+        if (options.scope && !['project', 'user'].includes(options.scope))
+            throw new Error('Invalid writer profile scope');
+        this.directory = path.join(options.scope === 'user'
+            ? resolveUserConfigDir({ configDir: options.userConfigDir })
+            : path.resolve(options.cwd, '.aiwg'), 'writer-profiles');
+    }
+    profilePath(id) {
+        if (!/^[a-z0-9][a-z0-9.-]{0,79}$/.test(id) || id.includes('..'))
+            throw new Error('Invalid writer profile ID');
+        return path.join(this.directory, `${id}.json`);
+    }
+    managedMigrationBackupDirectory(id) {
+        this.profilePath(id);
+        return path.join(this.directory, 'migration-backups', id);
+    }
+    async regularFile(file) {
+        const stat = await lstat(file);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error('Writer profile must be a regular file');
+    }
+    async read(id) {
+        const file = this.profilePath(id);
+        await this.regularFile(file);
+        const profile = parseWriterProfile(JSON.parse(await readFile(file, 'utf8')));
+        if (profile.id !== id)
+            throw new Error('Writer profile ID mismatch');
+        return profile;
+    }
+    async list() {
+        try {
+            const files = await readdir(this.directory, { withFileTypes: true });
+            return files.filter(file => file.isFile() && /^[a-z0-9][a-z0-9.-]*\.json$/.test(file.name))
+                .map(file => file.name.slice(0, -5)).sort();
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+    }
+    async locked(id, action) {
+        const file = this.profilePath(id);
+        await mkdir(this.directory, { recursive: true, mode: 0o700 });
+        const lock = `${file}.lock`;
+        try {
+            await mkdir(lock, { mode: 0o700 });
+        }
+        catch (error) {
+            if (error.code === 'EEXIST')
+                throw new Error('Writer profile is locked by another operation');
+            throw error;
+        }
+        try {
+            return await action();
+        }
+        finally {
+            await rm(lock, { recursive: true, force: true });
+        }
+    }
+    /** expectedRevision=0 creates; updates require the current revision. */
+    async save(input, expectedRevision, options = {}) {
+        const profile = parseWriterProfile(input);
+        return this.locked(profile.id, async () => {
+            let current;
+            try {
+                current = await this.read(profile.id);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            if ((current?.revision ?? 0) !== expectedRevision)
+                throw new Error('Writer profile revision conflict');
+            const next = parseWriterProfile({ ...profile, revision: expectedRevision + 1 });
+            const file = this.profilePath(profile.id);
+            const temporary = `${file}.${randomUUID()}.tmp`;
+            try {
+                await writeFile(temporary, JSON.stringify(next, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+                // Invalidate before publishing: an interrupted update may lose cache, never retain stale text.
+                await this.invalidate(profile.id, options);
+                await rename(temporary, file);
+            }
+            finally {
+                await rm(temporary, { force: true });
+            }
+            return next;
+        });
+    }
+    async invalidate(id, options = {}) {
+        this.profilePath(id);
+        // This store deliberately retains no historical sample content.
+        for (const kind of ['cache', 'history']) {
+            await rm(path.join(this.directory, kind, id), { recursive: true, force: true });
+        }
+        if (!options.preserveMigrationBackups)
+            await rm(this.managedMigrationBackupDirectory(id), { recursive: true, force: true });
+    }
+    async delete(id, expectedRevision) {
+        await this.locked(id, async () => {
+            const current = await this.read(id);
+            if (current.revision !== expectedRevision)
+                throw new Error('Writer profile revision conflict');
+            await this.invalidate(id);
+            await rm(this.profilePath(id));
+        });
+    }
+}
+//# sourceMappingURL=writer-profile-store.js.map

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

@@ -0,0 +1,222 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { redactText } from '../governance/redaction.js';
+import { validateLegacyWriterProfile } from './writer-profile-legacy.js';
+const hash = (text) => createHash('sha256').update(text).digest('hex');
+const id = z.string().min(1).max(120).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/);
+const provenance = z.object({ source: z.string().min(1).max(2000), license: z.string().min(1).max(200) }).strict();
+const evidence = z.object({ sampleId: id, start: z.number().int().nonnegative(), end: z.number().int().positive() }).strict();
+/** Closed expression controls exclude identity, personality and generated signature phrases. */
+export const writerPreferenceValues = {
+    dialect: ['unspecified', 'en-US', 'en-GB', 'en-AU', 'en-CA', 'fr-FR', 'fr-CA'],
+    register: ['conversational', 'professional', 'technical', 'formal'],
+    formality: ['casual', 'neutral', 'formal'],
+    warmth: ['reserved', 'neutral', 'warm'],
+    directness: ['gentle', 'neutral', 'direct'],
+    sentenceLength: ['short', 'varied', 'long'],
+    paragraphLength: ['short', 'varied', 'long'],
+    contractions: ['prefer', 'avoid', 'contextual'],
+    punctuation: ['minimal', 'varied', 'contextual'],
+    lexicalChoice: ['familiar', 'technical', 'contextual'],
+    rhetoric: ['plain', 'illustrative', 'contextual'],
+    structure: ['prose', 'lists', 'contextual'],
+};
+const preferenceKey = z.enum(Object.keys(writerPreferenceValues));
+const preference = z.object({
+    id, key: preferenceKey, value: z.string(), origin: z.enum(['explicit', 'inferred']),
+    confidence: z.enum(['low', 'moderate', 'high']), evidence: z.array(evidence).default([]),
+    task: z.string().max(120).optional(), status: z.enum(['accepted', 'rejected']).default('accepted'),
+}).strict();
+const override = z.object({ key: preferenceKey, action: z.enum(['set', 'reject', 'reset']), value: z.string().optional(), task: z.string().max(120).optional() }).strict();
+const sample = z.object({
+    id, text: z.string().max(1_000_000).optional(), sha256: z.string().regex(/^[a-f0-9]{64}$/), approved: z.boolean(),
+    status: z.enum(['active', 'revoked']), provenance,
+    rights: z.object({ useForVoice: z.boolean(), shareText: z.boolean() }).strict(),
+    sensitivity: z.enum(['public', 'private', 'secret']),
+}).strict();
+export const legacyProfileAttachmentSchema = z.object({
+    format: z.enum(['yaml', 'json']),
+    kind: z.enum(['addon-template', 'python-generated', 'python-analyzed', 'python-blended', 'ts-analyzer', 'ts-calibration']),
+    raw: z.string(), sha256: z.string().regex(/^[a-f0-9]{64}$/), payload: z.unknown(),
+}).strict();
+export const writerProfileSchema = z.object({
+    schemaVersion: z.literal(1), revision: z.number().int().positive().default(1), metadataSharingApproved: z.boolean().default(false), id: z.string().regex(/^[a-z0-9][a-z0-9.-]{0,79}$/).refine(v => !v.includes('..')), version: z.string().regex(/^\d+\.\d+\.\d+$/), name: z.string().min(1).max(200), provenance,
+    samples: z.array(sample), preferences: z.array(preference), overrides: z.array(override).default([]),
+    counterexamples: z.array(evidence).default([]), legacy: legacyProfileAttachmentSchema.optional(),
+    cacheEpoch: z.number().int().nonnegative().default(0),
+}).strict().superRefine((p, ctx) => {
+    const problem = (message) => ctx.addIssue({ code: z.ZodIssueCode.custom, message });
+    if (new Set(p.samples.map(s => s.id)).size !== p.samples.length)
+        problem('Duplicate sample IDs');
+    if (new Set(p.preferences.map(s => s.id)).size !== p.preferences.length)
+        problem('Duplicate preference IDs');
+    const samples = new Map(p.samples.map(s => [s.id, s]));
+    for (const s of p.samples) {
+        if (s.text !== undefined && hash(s.text) !== s.sha256)
+            problem('Sample integrity mismatch');
+        if (s.status === 'revoked' && s.text !== undefined)
+            problem('Revoked sample must not retain text');
+        if (s.sensitivity === 'secret' && s.rights.shareText)
+            problem('Secret samples cannot permit sharing');
+    }
+    const checkEvidence = (e) => {
+        const s = samples.get(e.sampleId);
+        if (!s || !s.approved || !s.rights.useForVoice || s.status !== 'active' || s.sensitivity === 'secret' || s.text === undefined || e.start >= e.end || e.end > s.text.length)
+            problem('Evidence must reference an approved usable sample span');
+        if (s?.text) {
+            // Do not allow a span boundary to split a surrogate pair.
+            for (const offset of [e.start, e.end])
+                if (offset > 0 && offset < s.text.length && /[\uD800-\uDBFF]/.test(s.text[offset - 1]) && /[\uDC00-\uDFFF]/.test(s.text[offset]))
+                    problem('Evidence splits a Unicode code point');
+        }
+    };
+    for (const pref of p.preferences) {
+        if (!writerPreferenceValues[pref.key].includes(pref.value))
+            problem('Unsupported expression value');
+        if (pref.origin === 'inferred' && !pref.evidence.length)
+            problem('Inferred preference requires evidence');
+        pref.evidence.forEach(checkEvidence);
+    }
+    for (const o of p.overrides) {
+        if (o.action === 'set' && (!o.value || !writerPreferenceValues[o.key].includes(o.value)))
+            problem('Set override requires a supported value');
+        if (o.action !== 'set' && o.value !== undefined)
+            problem('Only set overrides accept a value');
+    }
+    p.counterexamples.forEach(checkEvidence);
+    if (p.legacy) {
+        try {
+            validateLegacyWriterProfile(p.legacy);
+        }
+        catch {
+            problem('Legacy attachment integrity mismatch');
+        }
+    }
+});
+/** Errors never echo personal text, schema values or raw legacy payloads. */
+export function parseWriterProfile(input) {
+    const parsed = writerProfileSchema.safeParse(input);
+    if (!parsed.success)
+        throw new Error('Invalid writer profile: schema, evidence, rights or integrity validation failed');
+    return parsed.data;
+}
+export function compileWriterProfile(input, options = {}) {
+    const p = parseWriterProfile(input);
+    const settings = {};
+    const diagnostics = [];
+    const scopeMatches = (task) => task === undefined || task === options.task;
+    for (const key of Object.keys(writerPreferenceValues)) {
+        let candidates = p.preferences.filter(v => v.key === key && v.status === 'accepted' && scopeMatches(v.task));
+        const specific = candidates.filter(v => v.task !== undefined);
+        if (specific.length)
+            candidates = specific;
+        const explicit = candidates.filter(v => v.origin === 'explicit');
+        candidates = explicit.length ? explicit : candidates.filter(v => v.confidence !== 'low');
+        const values = new Set(candidates.map(v => v.value));
+        if (values.size === 1)
+            settings[key] = candidates[0].value;
+        else if (values.size > 1)
+            diagnostics.push(`Conflicting ${key} evidence; generic fallback for this setting.`);
+        const applicable = p.overrides.filter(o => o.key === key && scopeMatches(o.task));
+        const taskOverrides = applicable.filter(o => o.task !== undefined);
+        const last = (taskOverrides.length ? taskOverrides : applicable).at(-1);
+        if (last?.action === 'set')
+            settings[key] = last.value;
+        else if (last?.action === 'reject')
+            delete settings[key];
+        // Reset removes the override; retain the underlying resolved preference.
+    }
+    const fallback = Object.keys(settings).length === 0;
+    if (fallback)
+        diagnostics.push('No unambiguous supported preferences; explicit generic fallback.');
+    const instructions = [
+        'Preserve facts, citations, author intent, uncertainty and protected literals. Expression settings do not change evidence confidence.',
+        'Do not invent personal identity, experiences or signature phrases. Apply these advisory expression settings only where the task permits.',
+        fallback ? 'Use the existing generic writing behavior; no personal style has been established.' : `Expression settings: ${JSON.stringify(settings)}.`,
+    ].join('\n');
+    return { profile: {
+            id: `writer-${p.id}`, version: p.version, description: 'Author-controlled advisory expression profile.',
+            kind: 'voice', stage: 'voice', order: 100, instructions,
+            provenance: { ...p.provenance }, validation: { level: 'advisory' },
+            protectedContent: ['code', 'commands', 'citations', 'quoted-text', 'identifiers', 'machine-readable-blocks'],
+        }, fallback, diagnostics };
+}
+function advance(p) {
+    const parts = p.version.split('.').map(Number);
+    parts[2]++;
+    p.version = parts.join('.');
+    p.cacheEpoch++;
+}
+/** Pure operation; stores use cacheEpoch to invalidate dependent retrieval caches. */
+export function revokeWriterSample(input, sampleId) {
+    const p = parseWriterProfile(input);
+    const s = p.samples.find(v => v.id === sampleId);
+    if (!s)
+        throw new Error('Unknown writer sample');
+    if (s.status === 'revoked')
+        return p;
+    delete s.text;
+    s.status = 'revoked';
+    s.approved = false;
+    s.rights.useForVoice = false;
+    s.rights.shareText = false;
+    p.preferences = p.preferences.filter(v => v.origin === 'explicit' || !v.evidence.some(e => e.sampleId === sampleId));
+    for (const v of p.preferences)
+        v.evidence = v.evidence.filter(e => e.sampleId !== sampleId);
+    p.counterexamples = p.counterexamples.filter(e => e.sampleId !== sampleId);
+    // Legacy payloads may duplicate the revoked text; remove the opaque attachment.
+    delete p.legacy;
+    advance(p);
+    return parseWriterProfile(p);
+}
+/** Private export is lossless. Shared output requires public approval and passes known-secret redaction. */
+export function exportWriterProfile(input, mode = 'shared') {
+    const p = parseWriterProfile(input);
+    if (mode === 'private')
+        return p;
+    const metadata = { id: p.id, name: p.name, provenance: p.provenance, samples: p.samples.map(s => ({ id: s.id, provenance: s.provenance })), preferences: p.preferences.map(v => ({ id: v.id, task: v.task })), overrides: p.overrides };
+    if (redactText(JSON.stringify(metadata)).sensitivity === 'sensitive')
+        p.metadataSharingApproved = false;
+    const removed = new Set();
+    for (const s of p.samples) {
+        const allowed = s.status === 'active' && s.approved && s.sensitivity === 'public' && s.rights.shareText && (s.text === undefined || redactText(s.text).sensitivity === 'none');
+        if (!allowed) {
+            delete s.text;
+            removed.add(s.id);
+        }
+        if (!p.metadataSharingApproved)
+            s.provenance.source = '[redacted]';
+    }
+    p.preferences = p.preferences.filter(v => v.origin === 'explicit' || !v.evidence.some(e => removed.has(e.sampleId)));
+    for (const v of p.preferences)
+        v.evidence = v.evidence.filter(e => !removed.has(e.sampleId));
+    p.counterexamples = p.counterexamples.filter(e => removed.has(e.sampleId) === false);
+    if (mode === 'shared') {
+        delete p.legacy;
+        if (!p.metadataSharingApproved) {
+            p.id = 'shared-profile';
+            p.name = 'Shared writer profile';
+            p.provenance = { source: '[redacted]', license: '[redacted]' };
+            const ids = new Map(p.samples.map((s, i) => [s.id, `sample-${i + 1}`]));
+            for (const s of p.samples) {
+                s.id = ids.get(s.id);
+                s.provenance = { source: '[redacted]', license: '[redacted]' };
+            }
+            p.preferences = p.preferences.filter(v => v.task === undefined);
+            p.overrides = p.overrides.filter(v => v.task === undefined);
+            p.preferences.forEach((v, i) => { v.id = `preference-${i + 1}`; v.evidence.forEach(e => { e.sampleId = ids.get(e.sampleId); }); });
+            p.counterexamples.forEach(e => { e.sampleId = ids.get(e.sampleId); });
+        }
+    }
+    return parseWriterProfile(p);
+}
+/** Metadata-only inspection suitable for CLI logs; never includes sample text or preference evidence text. */
+export function inspectWriterProfile(input) {
+    const p = parseWriterProfile(input);
+    return { schemaVersion: p.schemaVersion, id: p.id, version: p.version, revision: p.revision, cacheEpoch: p.cacheEpoch,
+        sampleCount: p.samples.length, approvedSampleCount: p.samples.filter(s => s.approved && s.status === 'active').length,
+        preferenceCount: p.preferences.length, legacyFormat: p.legacy?.format ?? null,
+        fallback: compileWriterProfile(p).fallback,
+    };
+}
+//# sourceMappingURL=writer-profile.js.map

package/dist/src/writing/writing-brief.js

@@ -0,0 +1,166 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+const id = z.string().min(1).max(120).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/);
+const digest = z.string().regex(/^[a-f0-9]{64}$/);
+const text = z.string().min(1);
+const span = { start: z.number().int().nonnegative(), end: z.number().int().nonnegative() };
+const evidence = z.object({ inputId: id, ...span }).strict();
+const input = z.object({
+    id, kind: z.enum(['source', 'author-notes', 'existing-draft']), text,
+    sha256: digest, provenance: z.object({ source: text, version: text }).strict(),
+    authorApproved: z.boolean(),
+}).strict();
+const proposition = z.object({
+    id, text, evidenceStrength: z.enum(['verified', 'reported', 'preliminary', 'experimental', 'unverified']),
+    evidence: z.array(evidence).min(1), qualifiers: z.array(text),
+}).strict();
+const authorClaim = z.object({
+    id, kind: z.enum(['experience', 'opinion', 'intent', 'rationale']), text,
+    evidence: z.array(evidence).min(1),
+}).strict();
+const correction = z.object({
+    id, ...span, expected: z.string(), replacement: z.string(), reason: text,
+    authorAuthorized: z.literal(true),
+}).strict();
+export const writingBriefSchema = z.object({
+    schemaVersion: z.literal(1), id,
+    operation: z.enum(['draft-from-notes', 'edit-existing', 'proofread-only', 'continue-author-text']),
+    reader: z.object({ task: z.string(), audience: text, requirements: z.array(text) }).strict(),
+    intendedAction: z.string(), exclusions: z.array(text), inputs: z.array(input),
+    propositions: z.array(proposition), limitations: z.array(proposition), authorClaims: z.array(authorClaim),
+    sourceInputId: id.optional(),
+    permissions: z.object({ rephrase: z.boolean(), reorder: z.boolean(), addContent: z.boolean(), corrections: z.array(correction) }).strict(),
+}).strict();
+export const writingBriefHash = (value) => createHash('sha256').update(value, 'utf8').digest('hex');
+function boundary(source, offset) {
+    return offset >= 0 && offset <= source.length
+        && !(offset > 0 && offset < source.length && /[\uD800-\uDBFF]/.test(source[offset - 1]) && /[\uDC00-\uDFFF]/.test(source[offset]));
+}
+function overlaps(a, b) {
+    return a.start === a.end ? a.start >= b.start && a.start <= b.end : a.start < b.end && a.end > b.start;
+}
+/** Structural checks prove reference/permission integrity, not truth or semantic entailment. */
+export function validateWritingBrief(value) {
+    const parsed = writingBriefSchema.safeParse(value);
+    if (!parsed.success)
+        return { valid: false, diagnostics: [{ code: 'schema', message: 'Invalid writing brief shape; input text is omitted.' }] };
+    const b = parsed.data;
+    const diagnostics = [];
+    const report = (code, message, referenceId) => diagnostics.push({ code, message, ...(referenceId ? { referenceId } : {}) });
+    if (!b.reader.task.trim())
+        report('editorial-gap', 'Supply the reader task before drafting.');
+    if (!b.intendedAction.trim())
+        report('editorial-gap', 'Supply the intended reader action before drafting.');
+    if (!b.propositions.length)
+        report('editorial-gap', 'Supply supported propositions or look up context before drafting.');
+    for (const group of [b.inputs, [...b.propositions, ...b.limitations, ...b.authorClaims], b.permissions.corrections]) {
+        if (new Set(group.map(v => v.id)).size !== group.length)
+            report('reference', 'Duplicate identifiers are ambiguous.');
+    }
+    const inputs = new Map(b.inputs.map(v => [v.id, v]));
+    for (const i of b.inputs)
+        if (writingBriefHash(i.text) !== i.sha256)
+            report('integrity', 'Input digest mismatch.', i.id);
+    for (const claim of [...b.propositions, ...b.limitations, ...b.authorClaims]) {
+        for (const e of claim.evidence) {
+            const source = inputs.get(e.inputId);
+            if (!source || e.start >= e.end || !boundary(source.text, e.start) || !boundary(source.text, e.end))
+                report('reference', 'Evidence requires an existing input and a nonempty Unicode-safe span.', claim.id);
+            if ('kind' in claim && (!source || source.kind !== 'author-notes' || !source.authorApproved))
+                report('unsupported-claim', 'Personal experience, opinion, intent and rationale require approved author notes.', claim.id);
+        }
+        if ('kind' in claim && !claim.evidence.some(e => { const i = inputs.get(e.inputId); return i?.text.slice(e.start, e.end).includes(claim.text); }))
+            report('unsupported-claim', 'Author claim wording must occur in the cited approved notes; paraphrases require review.', claim.id);
+        if ('qualifiers' in claim && claim.qualifiers.some(q => !claim.text.includes(q)))
+            report('protected-content', 'A declared qualifier is missing from its proposition.', claim.id);
+        if ('evidenceStrength' in claim && claim.evidenceStrength === 'experimental' && !claim.qualifiers.length)
+            report('protected-content', 'Experimental propositions require an explicit protected qualifier.', claim.id);
+    }
+    const source = b.sourceInputId ? inputs.get(b.sourceInputId) : undefined;
+    if (b.sourceInputId && !source)
+        report('reference', 'Selected draft input does not exist.');
+    if (b.operation !== 'draft-from-notes' && (!source || source.kind !== 'existing-draft'))
+        report('editorial-gap', 'This operation requires an existing author draft.');
+    if (b.operation === 'proofread-only' && (b.permissions.rephrase || b.permissions.reorder || b.permissions.addContent))
+        report('permission', 'Proofread-only permits listed corrections, not rewriting, reordering or additions.');
+    if (b.operation === 'continue-author-text' && (b.permissions.rephrase || b.permissions.reorder || !b.permissions.addContent))
+        report('permission', 'Continuation preserves the source prefix and permits only appended content.');
+    for (const c of b.permissions.corrections) {
+        if (!source || c.start > c.end || !boundary(source.text, c.start) || !boundary(source.text, c.end) || source.text.slice(c.start, c.end) !== c.expected)
+            report('integrity', 'Authorized correction does not match its source span.', c.id);
+    }
+    return { valid: diagnostics.length === 0, diagnostics };
+}
+/** Parse only a complete, internally consistent brief; no guessed task, intent or sources. */
+export function parseWritingBrief(value) {
+    const check = validateWritingBrief(value);
+    if (!check.valid)
+        throw new Error(`Writing brief requires review: ${[...new Set(check.diagnostics.map(d => d.code))].join(', ')}. Source text is omitted.`);
+    return writingBriefSchema.parse(value);
+}
+/** Parameterization changes presentation targets only, never the brief or confidence. */
+export function prepareWritingBrief(value, target) {
+    const b = parseWritingBrief(value);
+    const selection = z.object({ profileId: id, channel: z.enum(['article', 'social', 'email', 'engineering', 'conversation']) }).strict().safeParse(target);
+    if (!selection.success)
+        throw new Error('Invalid writing brief target; input text is omitted.');
+    return { brief: structuredClone(b), target: selection.data, briefDigest: writingBriefHash(JSON.stringify(b)),
+        lineage: b.inputs.map(i => ({ inputId: i.id, sha256: i.sha256, role: i.kind })),
+        operation: b.operation, permissions: structuredClone(b.permissions), factualVerification: 'not-performed' };
+}
+/** Exact supported wording only. Paraphrases need review; matching IDs alone cannot approve invented text. */
+export function validateBriefClaims(value, proposed) {
+    const check = validateWritingBrief(value);
+    if (!check.valid)
+        return check;
+    const b = parseWritingBrief(value);
+    const proposal = z.array(z.object({ kind: z.enum(['proposition', 'experience', 'opinion', 'intent', 'rationale']), text, groundedIn: z.array(id) }).strict()).safeParse(proposed);
+    if (!proposal.success)
+        return { valid: false, diagnostics: [{ code: 'schema', message: 'Invalid proposed claim shape; input text is omitted.' }] };
+    const claims = [...b.propositions.map(p => ({ ...p, kind: 'proposition' })), ...b.limitations.map(p => ({ ...p, kind: 'proposition' })), ...b.authorClaims];
+    const diagnostics = [];
+    for (const p of proposal.data) {
+        const matches = claims.filter(c => p.groundedIn.includes(c.id));
+        if (!p.groundedIn.length || matches.length !== new Set(p.groundedIn).size || !matches.some(c => c.kind === p.kind && c.text === p.text))
+            diagnostics.push({ code: 'unsupported-claim', message: 'Proposed claim needs supplied matching wording and grounded input lineage; paraphrase or new content requires author review.' });
+    }
+    return { valid: diagnostics.length === 0, diagnostics };
+}
+/** Apply only explicitly authorized, exact corrections; on any failure return the unchanged source. */
+export function applyProofreadCorrections(value, correctionIds) {
+    const structural = writingBriefSchema.safeParse(value);
+    const source = structural.success ? structural.data.inputs.find(i => i.id === structural.data.sourceInputId) : undefined;
+    const original = source?.text ?? '';
+    const result = (check, output = original, applied = []) => ({ ...check, text: output,
+        lineage: { sourceInputId: source?.id, sourceDigest: source?.sha256, finalDigest: writingBriefHash(output), correctionIds: applied,
+            ...(structural.success ? { briefDigest: writingBriefHash(JSON.stringify(structural.data)) } : {}) } });
+    const check = validateWritingBrief(value);
+    if (!check.valid)
+        return result(check);
+    const b = parseWritingBrief(value);
+    if (b.operation !== 'proofread-only')
+        return result({ valid: false, diagnostics: [{ code: 'permission', message: 'Correction application requires proofread-only operation.' }] });
+    if (!z.array(id).safeParse(correctionIds).success)
+        return result({ valid: false, diagnostics: [{ code: 'permission', message: 'Correction selection must contain authorized identifiers.' }] });
+    const corrections = correctionIds.map(key => b.permissions.corrections.find(c => c.id === key));
+    if (new Set(correctionIds).size !== correctionIds.length || corrections.some(c => !c))
+        return result({ valid: false, diagnostics: [{ code: 'permission', message: 'Only unique, explicitly authorized correction IDs may be applied.' }] });
+    const selected = corrections.filter((c) => !!c).sort((a, b) => a.start - b.start || a.end - b.end);
+    for (let i = 1; i < selected.length; i++)
+        if (overlaps(selected[i], selected[i - 1]) || selected[i].start === selected[i - 1].start)
+            return result({ valid: false, diagnostics: [{ code: 'permission', message: 'Overlapping corrections require author review.' }] });
+    // Protect cited source spans, including experimental qualifiers and limitations.
+    const protectedSpans = [...b.propositions, ...b.limitations, ...b.authorClaims].flatMap(c => c.evidence).filter(e => e.inputId === source.id);
+    const qualifiers = [...b.propositions, ...b.limitations].flatMap(c => c.qualifiers);
+    for (const q of qualifiers) {
+        for (let at = original.indexOf(q); at >= 0; at = original.indexOf(q, at + q.length))
+            protectedSpans.push({ inputId: source.id, start: at, end: at + q.length });
+    }
+    if (selected.some(c => c.expected !== c.replacement && protectedSpans.some(s => overlaps(c, s))))
+        return result({ valid: false, diagnostics: [{ code: 'protected-content', message: 'A correction changes grounded content or a protected qualification; author review is required.' }] });
+    let output = original;
+    for (const c of [...selected].reverse())
+        output = output.slice(0, c.start) + c.replacement + output.slice(c.end);
+    return result({ valid: true, diagnostics: [] }, output, selected.map(c => c.id));
+}
+//# sourceMappingURL=writing-brief.js.map

package/dist/src/writing/writing-channels.js

@@ -0,0 +1,63 @@
+import { applyWritingConsumer } from './writing-consumer.js';
+import { parseWritingBrief, writingBriefHash } from './writing-brief.js';
+import { getWritingChannelPack } from './channel-packs.js';
+export { getWritingChannelPack } from './channel-packs.js';
+function check(text, c) {
+    const issues = [];
+    const characters = [...text].length;
+    if (c.maxCharacters !== undefined && characters > c.maxCharacters)
+        issues.push('character-limit');
+    if (c.cta && text.split(c.cta).length !== 2)
+        issues.push('cta-must-occur-once');
+    if (c.requiredLiterals?.some(value => !text.includes(value)))
+        issues.push('required-literal');
+    if (c.forbiddenLiterals?.some(value => text.includes(value)))
+        issues.push('forbidden-literal');
+    return { valid: issues.length === 0, issues, characters, unit: 'unicode-code-points' };
+}
+/** Opt-in local consumer adapter. Packs are advisory; callbacks receive samples/briefs as data. */
+export async function applyWritingChannel(input, request) {
+    const pack = getWritingChannelPack(request.channel);
+    const brief = parseWritingBrief(request.brief);
+    const constraints = structuredClone(request.constraints ?? {});
+    if (constraints.maxCharacters !== undefined && (!Number.isSafeInteger(constraints.maxCharacters) || constraints.maxCharacters < 1))
+        throw new Error('Invalid channel character budget');
+    if (constraints.destination !== undefined && !['telegram', 'discord', 'other'].includes(constraints.destination))
+        throw new Error('Unknown channel destination');
+    if (constraints.onFailure !== undefined && !['fail', 'unaltered'].includes(constraints.onFailure))
+        throw new Error('Unknown channel failure policy');
+    for (const values of [constraints.requiredLiterals ?? [], constraints.forbiddenLiterals ?? [], constraints.cta === undefined ? [] : [constraints.cta]]) {
+        if (!Array.isArray(values) || values.some(value => typeof value !== 'string' || !value.trim()))
+            throw new Error('Channel literals must be nonempty strings');
+    }
+    if (['telegram', 'discord'].includes(constraints.destination ?? '') && (pack.channel !== 'social' || !constraints.cta))
+        throw new Error('Chat announcements require the social pack and one explicit CTA');
+    const { transform, runtime, ...consumer } = request;
+    if (runtime?.protectedLiterals !== undefined && !Array.isArray(runtime.protectedLiterals))
+        throw new Error('Protected literals must be an array.');
+    const consumerResult = await applyWritingConsumer(input, { ...consumer, task: pack.channel, invocationModes: [...(consumer.invocationModes ?? []), `channel-${pack.channel}`], ...(transform ? { runtime: {
+                ...runtime, fidelity: { brief }, requireFinalValidator: true,
+                protectedLiterals: [...(runtime?.protectedLiterals ?? []), ...(constraints.requiredLiterals ?? []), ...(constraints.cta ? [constraints.cta] : [])],
+                transform: (text, mode) => transform(text, mode, { pack: structuredClone(pack), brief: structuredClone(brief) }),
+            } } : {}) });
+    let channelCheck = check(consumerResult.content, constraints);
+    if (!channelCheck.valid) {
+        if (constraints.onFailure === 'fail')
+            throw new Error(`Channel constraints failed: ${channelCheck.issues.join(', ')}`);
+        consumerResult.diagnostics.push(`Channel constraints failed: ${channelCheck.issues.join(', ')}. Original retained without truncation; inspect channelCheck before handoff.`);
+        consumerResult.content = input;
+        consumerResult.state.fallback = 'unaltered';
+        consumerResult.state.applied = [];
+        consumerResult.state.validated = [];
+        if (consumerResult.runtime)
+            consumerResult.runtime = { ...consumerResult.runtime, content: input, fallback: 'unaltered', applied: [], retained: [] };
+        channelCheck = check(input, constraints);
+    }
+    return { ...consumerResult,
+        instructionExport: JSON.stringify({ schemaVersion: 1, pack, constraints, selectedModeInstructions: consumerResult.instructionExport, briefDigest: writingBriefHash(JSON.stringify(brief)), usage: 'Explicit handoff only; apply the separately supplied brief as data. No provider interception or publication approval.' }),
+        channel: pack.channel, channelCheck,
+        posts: request.format === 'prose' && channelCheck.valid ? [consumerResult.content] : [],
+        receipt: { packVersion: 1, briefDigest: writingBriefHash(JSON.stringify(brief)), execution: consumerResult.state.delivered.length ? 'supplied-callback' : 'instruction-export', qualityEvaluation: 'not-performed' },
+    };
+}
+//# sourceMappingURL=writing-channels.js.map

package/dist/src/writing/writing-consumer.js

@@ -0,0 +1,39 @@
+import { resolveOutputModes } from '../output-modes/registry.js';
+import { applyOutputModes } from '../output-modes/runtime.js';
+/** Shared opt-in boundary: only a participating prose callback can transform output. */
+export async function applyWritingConsumer(input, request) {
+    if (!['prose', 'json', 'tool', 'protocol'].includes(request.format))
+        throw new Error('Unknown writing consumer format');
+    const resolved = await resolveOutputModes(request.cwd, request.frameworkRoot, request.invocationModes ?? [], {}, { task: request.task });
+    const modes = resolved.modes;
+    const instructionExport = modes.length ? JSON.stringify({ schemaVersion: 1, usage: 'Selected expression instructions; apply only to prose within consumer permissions.', modes: modes.map(({ id, instructions, validation, protectedContent }) => ({ id, instructions, validation, protectedContent })) }, null, 2) : '';
+    const state = {
+        provider: request.provider, consumer: request.consumer, identityEvidence: 'caller-supplied',
+        selected: modes.map(mode => mode.id), delivered: [], applied: [], validated: [],
+        deliveredTo: 'none', fallback: 'none', providerInterception: false,
+    };
+    const result = { content: input, modes, instructionExport, diagnostics: [...resolved.diagnostics], state };
+    if (request.format !== 'prose') {
+        result.diagnostics.push('Structured output is unchanged. A participating consumer must explicitly select a prose field before applying modes.');
+        return result;
+    }
+    if (!request.runtime) {
+        if (modes.length) {
+            result.diagnostics.push('This consumer has no transformation callback. Use the instruction export explicitly; selection does not intercept provider responses.');
+            state.fallback = 'unaltered';
+        }
+        return result;
+    }
+    const runtime = await applyOutputModes(input, modes, request.runtime);
+    result.content = runtime.content;
+    result.runtime = runtime;
+    state.delivered = [...(runtime.attempted ?? runtime.applied)];
+    state.deliveredTo = state.delivered.length ? 'local-transform-callback' : 'none';
+    state.applied = [...(runtime.retained ?? runtime.applied)];
+    state.fallback = runtime.fallback;
+    if (runtime.fallback === 'none')
+        state.validated = state.applied.filter(id => modes.find(mode => mode.id === id)?.validation.level !== 'advisory');
+    result.diagnostics.push(...runtime.diagnostics.map(diagnostic => diagnostic.message));
+    return result;
+}
+//# sourceMappingURL=writing-consumer.js.map