@ornexus/neocortex 4.60.18 → 4.60.19

package/packages/shared/dist/invocation/index.js

@@ -0,0 +1,587 @@
+/**
+ * P205.07 -- sole executable invocation-admission authority.
+ *
+ * This parser deliberately implements a small finite grammar. It is not an
+ * argv or shell parser and never expands, evaluates, interpolates or repairs
+ * user input.
+ */
+import { createHash } from 'node:crypto';
+import { COMMAND_REGISTRY_CHECKSUM, COMMAND_REGISTRY_VERSION, GENERATED_SHARED_COMMANDS, } from '../generated/command-registry.generated.js';
+import { GENERATED_INVOCATION_SCHEMA_MANIFEST, GENERATED_INVOCATION_SCHEMAS, } from '../generated/invocation-schema.generated.js';
+import { canonicalizeCommandRegistryJcs } from '../command-registry-contract.js';
+export const EXACT_INVOCATION_POLICY = 'p205-exact-invocation-v1';
+export const INVOCATION_SCHEMA_VERSION = 'p205-invocation-schema-v1';
+export const INVOCATION_LIMITS = Object.freeze({
+    inputBytes: 64 * 1024,
+    tokens: 512,
+    tokenBytes: 16 * 1024,
+    briefBytes: 16 * 1024,
+    receiptBytes: 2048,
+    suggestions: 5,
+});
+const freeze = (value) => {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        for (const child of Object.values(value))
+            freeze(child);
+        Object.freeze(value);
+    }
+    return value;
+};
+const commands = [...GENERATED_SHARED_COMMANDS]
+    .filter((entry) => entry.visibility === 'public')
+    .sort((a, b) => a.id.localeCompare(b.id, 'en'));
+const byId = new Map(commands.map((entry) => [entry.id, entry]));
+const byAlias = new Map(commands.flatMap((entry) => entry.aliases.map((alias) => [alias, entry])));
+const byNumber = new Map(commands.map((entry) => [String(entry.number), entry]));
+const invocationSchemas = GENERATED_INVOCATION_SCHEMAS;
+const schemaByCommand = new Map(invocationSchemas.map((schema) => [schema.commandId, schema]));
+export const INVOCATION_SCHEMA_CHECKSUM = GENERATED_INVOCATION_SCHEMA_MANIFEST.schemaChecksum;
+export const INVOCATION_SCHEMA_MANIFEST = freeze(GENERATED_INVOCATION_SCHEMA_MANIFEST);
+export function assertInvocationSchemaAdmission(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('INVOCATION_SCHEMA_INVALID');
+    const candidate = value;
+    const exactKeys = ['commandCount', 'commands', 'operationCount', 'optionCount', 'positionalCount', 'projectionSha256', 'registryChecksum', 'registryVersion', 'schemaChecksum', 'schemaVersion'];
+    if (Object.keys(candidate).sort().join('\0') !== exactKeys.join('\0'))
+        throw new Error('INVOCATION_SCHEMA_INVALID');
+    if (candidate.schemaVersion !== INVOCATION_SCHEMA_VERSION
+        || candidate.registryVersion !== COMMAND_REGISTRY_VERSION
+        || candidate.registryChecksum !== COMMAND_REGISTRY_CHECKSUM
+        || candidate.schemaChecksum !== INVOCATION_SCHEMA_CHECKSUM
+        || !Array.isArray(candidate.commands))
+        throw new Error('INVOCATION_SCHEMA_DRIFT');
+    const schemaProjection = {
+        schemaVersion: candidate.schemaVersion,
+        registryVersion: candidate.registryVersion,
+        registryChecksum: candidate.registryChecksum,
+        commands: candidate.commands,
+    };
+    let schemaChecksum = '';
+    let projectionSha256 = '';
+    try {
+        schemaChecksum = createHash('sha256').update(canonicalizeCommandRegistryJcs(schemaProjection)).digest('hex');
+        projectionSha256 = createHash('sha256').update(canonicalizeCommandRegistryJcs(candidate.commands)).digest('hex');
+    }
+    catch {
+        throw new Error('INVOCATION_SCHEMA_INVALID');
+    }
+    if (schemaChecksum !== candidate.schemaChecksum || projectionSha256 !== candidate.projectionSha256
+        || JSON.stringify(candidate) !== JSON.stringify(GENERATED_INVOCATION_SCHEMA_MANIFEST))
+        throw new Error('INVOCATION_SCHEMA_DRIFT');
+    const ids = invocationSchemas.map((schema) => schema.commandId);
+    if (new Set(ids).size !== ids.length || JSON.stringify(ids) !== JSON.stringify(commands.map((command) => command.id))
+        || candidate.commandCount !== invocationSchemas.length
+        || candidate.optionCount !== invocationSchemas.reduce((sum, schema) => sum + schema.options.length, 0)
+        || candidate.positionalCount !== invocationSchemas.reduce((sum, schema) => sum + schema.positionals.length, 0)
+        || candidate.operationCount !== invocationSchemas.reduce((sum, schema) => sum + schema.operation.operations.length, 0)
+        || invocationSchemas.some((schema) => {
+            const command = byId.get(schema.commandId);
+            return !command || command.inputShape !== schema.inputShape
+                || JSON.stringify(schema.operation.operations) !== JSON.stringify(command.subcommands.map(({ id, aliases }) => ({ id, aliases })));
+        })) {
+        throw new Error('INVOCATION_SCHEMA_COVERAGE');
+    }
+}
+assertInvocationSchemaAdmission(INVOCATION_SCHEMA_MANIFEST);
+function byteLength(value) {
+    return Buffer.byteLength(value, 'utf8');
+}
+function bucket(bytes) {
+    if (bytes === 0)
+        return '0';
+    if (bytes <= 64)
+        return '1-64';
+    if (bytes <= 256)
+        return '65-256';
+    if (bytes <= 1024)
+        return '257-1024';
+    if (bytes <= 4096)
+        return '1025-4096';
+    if (bytes <= 16384)
+        return '4097-16384';
+    return '16385-65536';
+}
+export function lexInvocationEnvelope(input) {
+    const inputBytes = byteLength(input);
+    if (inputBytes > INVOCATION_LIMITS.inputBytes)
+        return { ok: false, reason: 'input_limit', tokenCount: 0 };
+    for (let i = 0; i < input.length; i += 1) {
+        const code = input.charCodeAt(i);
+        if (code === 0 || (code < 0x20 && code !== 0x09 && code !== 0x0a && code !== 0x0d) || code === 0x7f) {
+            return { ok: false, reason: 'invalid_control', tokenCount: 0 };
+        }
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = input.charCodeAt(i + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                return { ok: false, reason: 'invalid_surrogate', tokenCount: 0 };
+            i += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            return { ok: false, reason: 'invalid_surrogate', tokenCount: 0 };
+        }
+    }
+    const tokens = [];
+    let value = '';
+    let tokenStart = -1;
+    let quote = false;
+    let segmentQuote = false;
+    let segmentStart = -1;
+    let escaped = false;
+    let touched = false;
+    let whollyUnquoted = true;
+    let segments = [];
+    const closeSegment = (end) => {
+        if (segmentStart >= 0)
+            segments.push({ quoted: segmentQuote, start: segmentStart, end });
+        segmentStart = -1;
+    };
+    const startSegment = (at, quoted) => {
+        if (segmentStart >= 0 && segmentQuote !== quoted)
+            closeSegment(at);
+        if (segmentStart < 0) {
+            segmentStart = at;
+            segmentQuote = quoted;
+        }
+    };
+    const emit = (end) => {
+        if (!touched)
+            return null;
+        closeSegment(end);
+        if (byteLength(value) > INVOCATION_LIMITS.tokenBytes)
+            return { ok: false, reason: 'token_size_limit', tokenCount: tokens.length };
+        tokens.push(freeze({ value, start: tokenStart, end, whollyUnquoted, segments }));
+        if (tokens.length > INVOCATION_LIMITS.tokens)
+            return { ok: false, reason: 'token_limit', tokenCount: tokens.length };
+        value = '';
+        tokenStart = -1;
+        touched = false;
+        whollyUnquoted = true;
+        segments = [];
+        return null;
+    };
+    for (let i = 0; i < input.length; i += 1) {
+        const char = input[i];
+        if (escaped) {
+            const allowed = char === '\\' || char === ' ' || char === '\t' || char === '\r' || char === '\n'
+                || (quote === 'single' && char === "'") || (quote === 'double' && char === '"');
+            if (!allowed)
+                return { ok: false, reason: 'unsupported_escape', tokenCount: tokens.length };
+            startSegment(i - 1, quote);
+            value += char;
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            if (!touched) {
+                touched = true;
+                tokenStart = i;
+            }
+            startSegment(i, quote);
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if ((quote === 'single' && char === "'") || (quote === 'double' && char === '"')) {
+                closeSegment(i + 1);
+                quote = false;
+            }
+            else {
+                startSegment(i, quote);
+                value += char;
+            }
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            if (!touched) {
+                touched = true;
+                tokenStart = i;
+            }
+            whollyUnquoted = false;
+            closeSegment(i);
+            quote = char === "'" ? 'single' : 'double';
+            startSegment(i, quote);
+            continue;
+        }
+        if (char === ' ' || char === '\t' || char === '\r' || char === '\n') {
+            const emitted = emit(i);
+            if (emitted)
+                return emitted;
+            continue;
+        }
+        if (!touched) {
+            touched = true;
+            tokenStart = i;
+        }
+        startSegment(i, false);
+        value += char;
+    }
+    if (escaped)
+        return { ok: false, reason: 'trailing_escape', tokenCount: tokens.length };
+    if (quote)
+        return { ok: false, reason: 'unterminated_quote', tokenCount: tokens.length };
+    const emitted = emit(input.length);
+    return emitted ?? { ok: true, tokens: freeze(tokens) };
+}
+function editDistance(left, right) {
+    const row = Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let i = 1; i <= left.length; i += 1) {
+        let diagonal = row[0];
+        row[0] = i;
+        for (let j = 1; j <= right.length; j += 1) {
+            const above = row[j];
+            row[j] = Math.min(row[j] + 1, row[j - 1] + 1, diagonal + (left[i - 1] === right[j - 1] ? 0 : 1));
+            diagonal = above;
+        }
+    }
+    return row[right.length];
+}
+function suggestionsFor(token) {
+    const normalized = token.replace(/^\*/, '').toLowerCase();
+    if (!/^[a-z0-9?-]{2,64}$/.test(normalized))
+        return [];
+    if (/^\d+$/.test(normalized))
+        return [];
+    return commands
+        .map((command) => {
+        const identities = [command.id, ...command.aliases];
+        const score = Math.min(...identities.map((identity) => identity.startsWith(normalized) || normalized.startsWith(identity) ? 0 : editDistance(normalized, identity)));
+        return { id: command.id, score };
+    })
+        .filter((candidate) => candidate.score <= Math.max(2, Math.floor(normalized.length / 3)))
+        .sort((a, b) => a.score - b.score || a.id.localeCompare(b.id, 'en'))
+        .slice(0, INVOCATION_LIMITS.suggestions)
+        .map((candidate) => candidate.id);
+}
+function base(reason, tokenCount, bytes) {
+    return {
+        policy: EXACT_INVOCATION_POLICY,
+        schemaVersion: INVOCATION_SCHEMA_VERSION,
+        registryVersion: COMMAND_REGISTRY_VERSION,
+        registryChecksum: COMMAND_REGISTRY_CHECKSUM,
+        schemaChecksum: INVOCATION_SCHEMA_CHECKSUM,
+        reason,
+        tokenCount,
+        inputBytesBucket: bucket(bytes),
+    };
+}
+function reject(outcome, reason, tokenCount, bytes, candidates = []) {
+    return freeze({
+        ...base(reason, tokenCount, bytes),
+        outcome,
+        executable: false,
+        mutationAttempts: 0,
+        candidates: [...candidates].slice(0, INVOCATION_LIMITS.suggestions),
+    });
+}
+function resolveIdentity(token) {
+    if (!token.whollyUnquoted)
+        return null;
+    const normalized = token.value.replace(/^\*/, '').toLowerCase();
+    if (normalized !== '?' && !/^(?:[a-z][a-z0-9?-]*|[1-9][0-9]*)$/.test(normalized))
+        return null;
+    return byId.get(normalized) ?? byAlias.get(normalized) ?? byNumber.get(normalized) ?? null;
+}
+function validUrl(value) {
+    // URL consumers decode percent escapes after admission. Reject encoded C0
+    // controls and DEL here as well as literal controls so a value cannot cross
+    // this boundary clean and become control-bearing downstream.
+    if (/[\u0000-\u001f\u007f]/u.test(value) || /%(?:0[0-9a-f]|1[0-9a-f]|7f)/iu.test(value))
+        return false;
+    try {
+        const url = new URL(value);
+        return (url.protocol === 'http:' || url.protocol === 'https:') && !url.username && !url.password;
+    }
+    catch {
+        return false;
+    }
+}
+function validPath(value) {
+    return value.length > 0 && value.length <= 256 && !value.startsWith('/') && !value.startsWith('~')
+        && !value.includes('\\') && !value.includes('//')
+        && value.split('/').every((segment) => segment !== '' && segment !== '.' && segment !== '..')
+        && /^[A-Za-z0-9._/-]+$/.test(value);
+}
+function canonicalUiUx(value) {
+    return JSON.stringify({
+        architectureDir: value.architectureDir ?? null,
+        url: value.url ?? null,
+        surface: value.surface ?? null,
+        brand: value.brand ?? null,
+        designSystem: value.designSystem ?? null,
+        evidenceOut: value.evidenceOut ?? null,
+        reviewBrief: value.reviewBrief ?? null,
+        json: value.json,
+        screenshots: value.screenshots,
+        projectEvidence: value.projectEvidence,
+    });
+}
+function normalizeUiUx(positionals, options) {
+    let architectureDir = typeof options['architecture-dir'] === 'string' ? options['architecture-dir'] : undefined;
+    let url = typeof options.url === 'string' ? options.url : undefined;
+    const briefParts = [];
+    for (const positional of positionals) {
+        if (/^https?:\/\//i.test(positional)) {
+            if (url)
+                return 'argument_conflict';
+            url = positional;
+            continue;
+        }
+        if (/^(?:\.\/)?docs\//.test(positional) || positional.endsWith('.md')) {
+            if (architectureDir)
+                return 'argument_conflict';
+            architectureDir = positional;
+            continue;
+        }
+        briefParts.push(positional);
+    }
+    if (url && !validUrl(url))
+        return 'invalid_option_value';
+    if (architectureDir && !validPath(architectureDir))
+        return 'invalid_option_value';
+    const reviewBrief = briefParts.length ? briefParts.join(' ') : undefined;
+    if (reviewBrief && byteLength(reviewBrief) > INVOCATION_LIMITS.briefBytes)
+        return 'brief_limit';
+    const raw = {
+        ...(architectureDir ? { architectureDir } : {}),
+        ...(url ? { url } : {}),
+        ...(Array.isArray(options.surface) ? { surface: options.surface } : {}),
+        ...(typeof options.brand === 'string' ? { brand: options.brand } : {}),
+        ...(typeof options['design-system'] === 'string' ? { designSystem: options['design-system'] } : {}),
+        ...(typeof options['evidence-out'] === 'string' ? { evidenceOut: options['evidence-out'] } : {}),
+        ...(reviewBrief ? { reviewBrief } : {}),
+        json: options.json === true,
+        screenshots: options.screenshots === true,
+        projectEvidence: options['project-evidence'] === true,
+    };
+    const fingerprint = createHash('sha256').update(`p205-uiux-brief-v1\0${canonicalUiUx(raw)}`).digest('hex');
+    return freeze({ ...raw, fingerprint });
+}
+function validPositional(kind, value) {
+    if (!value.length || byteLength(value) > INVOCATION_LIMITS.tokenBytes)
+        return false;
+    if (kind === 'story-ref') {
+        return /^@?(?:docs\/stories\/[A-Za-z0-9._/-]+\.story\.md|P\d+\.\d+|story-P\d+\.\d+)$/.test(value);
+    }
+    if (kind === 'epic-ref') {
+        return /^@?(?:docs\/epics\/epic-P\d+\.md|P\d+|epic-P\d+(?:\.md)?)$/i.test(value);
+    }
+    if (kind === 'target-ref') {
+        const target = value.startsWith('@') ? value.slice(1) : value;
+        // Directory mode is a canonical yoloop target. Keep general path
+        // admission strict while explicitly accepting its single trailing slash.
+        return /^(?:P\d+|EPIC-\d+)$/i.test(target)
+            || /^docs\/epics\/?$/.test(target)
+            || validPath(target);
+    }
+    return true;
+}
+function admitPositionals(values, schemas) {
+    let offset = 0;
+    for (const schema of schemas) {
+        const count = schema.cardinality === 'many' ? values.length - offset : Math.min(1, values.length - offset);
+        if (schema.required && count === 0)
+            return 'positional_required';
+        const selected = values.slice(offset, offset + count);
+        if (selected.some((value) => !validPositional(schema.kind, value)))
+            return 'invalid_positional_value';
+        offset += count;
+    }
+    return offset === values.length ? undefined : 'positional_overflow';
+}
+function admitArguments(schema, tokens) {
+    const rules = new Map();
+    for (const rule of schema.options) {
+        rules.set(rule.id, rule);
+        for (const alias of rule.aliases)
+            rules.set(alias, rule);
+    }
+    const options = {};
+    const positionals = [];
+    let terminated = false;
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (!terminated && token.whollyUnquoted && token.value === '--') {
+            terminated = true;
+            continue;
+        }
+        if (!terminated && token.whollyUnquoted && token.value.startsWith('--')) {
+            const separator = token.value.indexOf('=');
+            const name = token.value.slice(2, separator < 0 ? undefined : separator);
+            const inline = separator < 0 ? undefined : token.value.slice(separator + 1);
+            const rule = rules.get(name);
+            if (!rule)
+                return 'unknown_option';
+            if (Object.hasOwn(options, rule.id) && rule.cardinality === 'one')
+                return 'duplicate_option';
+            if (rule.kind === 'boolean') {
+                if (inline !== undefined || !rule.syntax.includes('bare'))
+                    return 'unexpected_option_value';
+                options[rule.id] = true;
+                continue;
+            }
+            if (inline !== undefined && !rule.syntax.includes('inline'))
+                return 'invalid_option_value';
+            if (inline === undefined && !rule.syntax.includes('split'))
+                return 'invalid_option_value';
+            const next = inline ?? tokens[index + 1]?.value;
+            if (next === undefined || (inline === undefined && tokens[index + 1]?.whollyUnquoted && next.startsWith('--')))
+                return 'missing_option_value';
+            if (inline === undefined)
+                index += 1;
+            if (rule.valuePattern && !new RegExp(rule.valuePattern, 'u').test(next))
+                return 'invalid_option_value';
+            if (rule.kind === 'url' && !validUrl(next))
+                return 'invalid_option_value';
+            if (rule.kind === 'path' && !validPath(next))
+                return 'invalid_option_value';
+            if (rule.kind === 'string-list') {
+                const list = next.split(',').map((item) => item.trim()).filter(Boolean);
+                if (!list.length || list.some((item) => item.length > 128))
+                    return 'invalid_option_value';
+                options[rule.id] = freeze(list);
+            }
+            else {
+                if (!next.length || byteLength(next) > 4096)
+                    return 'invalid_option_value';
+                if (rule.cardinality === 'many' && Object.hasOwn(options, rule.id)) {
+                    const previous = options[rule.id];
+                    options[rule.id] = freeze([...(Array.isArray(previous) ? previous : [String(previous)]), next]);
+                }
+                else
+                    options[rule.id] = next;
+            }
+            continue;
+        }
+        positionals.push(token.value);
+    }
+    for (const rule of schema.options)
+        if (rule.required && !Object.hasOwn(options, rule.id))
+            return 'missing_option_value';
+    const positionalFailure = admitPositionals(positionals, schema.positionals);
+    if (positionalFailure)
+        return positionalFailure;
+    return freeze({ options, positionals });
+}
+function admitOperation(schema, tokens) {
+    if (!schema.operation.operations.length)
+        return { rest: tokens };
+    if (!tokens.length || (tokens[0].whollyUnquoted && tokens[0].value.startsWith('--'))) {
+        return schema.operation.required ? 'operation_required' : { rest: tokens };
+    }
+    const candidate = tokens[0];
+    const normalized = candidate.value.toLowerCase();
+    const operation = schema.operation.operations.find((entry) => entry.id === normalized || entry.aliases.includes(normalized));
+    if (operation && !candidate.whollyUnquoted)
+        return 'operation_quoted';
+    if (!operation) {
+        const resemblesOperation = schema.operation.operations.some((entry) => entry.id.startsWith(normalized) || normalized.startsWith(entry.id)
+            || entry.aliases.some((alias) => alias.startsWith(normalized) || normalized.startsWith(alias)));
+        if (resemblesOperation)
+            return candidate.whollyUnquoted ? 'operation_unknown' : 'operation_quoted';
+        if (!schema.operation.unknownAsPositional || schema.operation.required)
+            return candidate.whollyUnquoted ? 'operation_unknown' : 'operation_quoted';
+        return { rest: tokens }; // Schema explicitly classifies this slot as parent positional data.
+    }
+    return { operationId: operation.id, rest: tokens.slice(1) };
+}
+export function admitInvocation(input, options = {}) {
+    const bytes = byteLength(input);
+    if (options.policy !== undefined && options.policy !== EXACT_INVOCATION_POLICY)
+        return reject('malformed_input', 'policy_mismatch', 0, bytes);
+    if (options.registryVersion !== undefined && options.registryVersion !== COMMAND_REGISTRY_VERSION)
+        return reject('malformed_input', 'registry_mismatch', 0, bytes);
+    if (options.registryChecksum !== undefined && options.registryChecksum !== COMMAND_REGISTRY_CHECKSUM)
+        return reject('malformed_input', 'registry_mismatch', 0, bytes);
+    if (options.schemaChecksum !== undefined && options.schemaChecksum !== INVOCATION_SCHEMA_CHECKSUM)
+        return reject('malformed_input', 'schema_mismatch', 0, bytes);
+    const lexed = lexInvocationEnvelope(input);
+    if (!lexed.ok)
+        return reject('malformed_input', lexed.reason, lexed.tokenCount, bytes);
+    if (!lexed.tokens.length) {
+        const menu = byId.get('menu');
+        if (!menu)
+            return reject('unknown_command', 'identity_unknown', 0, bytes);
+        return resolved(menu, undefined, { options: {}, positionals: [] }, undefined, 0, bytes);
+    }
+    const command = resolveIdentity(lexed.tokens[0]);
+    if (!command) {
+        const candidates = suggestionsFor(lexed.tokens[0].value);
+        return reject(candidates.length ? 'ambiguous_command' : 'unknown_command', candidates.length ? 'suggestions_available' : 'identity_unknown', lexed.tokens.length, bytes, candidates);
+    }
+    const schema = schemaByCommand.get(command.id);
+    if (!schema)
+        return reject('malformed_input', 'schema_mismatch', lexed.tokens.length, bytes);
+    const operation = admitOperation(schema, lexed.tokens.slice(1));
+    if (typeof operation === 'string')
+        return reject('invalid_arguments', operation, lexed.tokens.length, bytes);
+    const parsed = admitArguments(schema, operation.rest);
+    if (typeof parsed === 'string')
+        return reject('invalid_arguments', parsed, lexed.tokens.length, bytes);
+    const uiUxReview = command.id === 'ui-ux-review' ? normalizeUiUx(parsed.positionals, parsed.options) : undefined;
+    if (typeof uiUxReview === 'string')
+        return reject('invalid_arguments', uiUxReview, lexed.tokens.length, bytes);
+    return resolved(command, operation.operationId, parsed, uiUxReview, lexed.tokens.length, bytes);
+}
+function resolved(command, operationId, parsed, uiUxReview, tokenCount, bytes) {
+    const selection = freeze({
+        commandId: command.id,
+        commandNumber: command.number,
+        ...(operationId ? { operationId } : {}),
+        inputShape: command.inputShape,
+        positionals: parsed.positionals,
+        options: parsed.options,
+        ...(uiUxReview ? { uiUxReview } : {}),
+        capability: {
+            policy: EXACT_INVOCATION_POLICY,
+            registryChecksum: COMMAND_REGISTRY_CHECKSUM,
+            commandId: command.id,
+            ...(operationId ? { operationId } : {}),
+        },
+    });
+    return freeze({ ...base('accepted', tokenCount, bytes), outcome: 'resolved', executable: true, candidates: [], selection });
+}
+export function createInvocationAdmissionReceipt(result, driver) {
+    const receipt = freeze({
+        schemaVersion: 1,
+        policy: EXACT_INVOCATION_POLICY,
+        registryVersion: result.registryVersion,
+        registryChecksumPrefix: result.registryChecksum.slice(0, 12),
+        schemaChecksumPrefix: result.schemaChecksum.slice(0, 12),
+        outcome: result.outcome,
+        reason: result.reason,
+        ...(result.outcome === 'resolved' ? {
+            commandId: result.selection.commandId,
+            ...(result.selection.operationId ? { operationId: result.selection.operationId } : {}),
+            ...(result.selection.uiUxReview ? { fingerprintPrefix: result.selection.uiUxReview.fingerprint.slice(0, 12) } : {}),
+        } : {}),
+        candidates: result.candidates.slice(0, INVOCATION_LIMITS.suggestions),
+        tokenCount: Math.min(result.tokenCount, INVOCATION_LIMITS.tokens + 1),
+        inputBytesBucket: result.inputBytesBucket,
+        driver,
+        mutationAttempts: result.outcome === 'resolved' ? 0 : result.mutationAttempts,
+        publicSafe: true,
+    });
+    if (byteLength(JSON.stringify(receipt)) > INVOCATION_LIMITS.receiptBytes)
+        throw new Error('INVOCATION_RECEIPT_BOUND_EXCEEDED');
+    return receipt;
+}
+export function serializeInvocationAdmission(result) {
+    return JSON.stringify(result);
+}
+export function strictRollbackAdmitInvocation(input) {
+    // Rollback may narrow optional normalized syntax but never bypasses the exact
+    // parser or its fail-before-effect decision.
+    return admitInvocation(input);
+}
+/** Count-only migration telemetry; raw input is intentionally not accepted. */
+export function createInvocationDeprecationCount(result) {
+    return Object.freeze({
+        schemaVersion: 1,
+        policy: EXACT_INVOCATION_POLICY,
+        outcome: result.outcome,
+        reason: result.reason,
+        count: 1,
+        expiresAfter: 'p205-exact-invocation-v1-rollout',
+        publicSafe: true,
+    });
+}