@receiz/mcp-server/dist/constitutional.js

MCP server for agents building and verifying Receiz proof-native applications through the canonical Receiz SDK rails.

import { createHash, randomUUID } from "node:crypto";
import { encodeReceizAuthority, RECEIZ_RULESET_VERSION } from "@receiz/sdk";
function authorityDigest(domain, schema, value) {
    return createHash("sha256").update(encodeReceizAuthority(domain, schema, value)).digest("hex");
}
export const RECEIZ_CURRENT_MCP_RULESET_VERSION = RECEIZ_RULESET_VERSION;
export const RECEIZ_CURRENT_MCP_PLAN_SCHEMA = "receiz.mcp.operation-plan.v125";
export const RECEIZ_CURRENT_MCP_PLAN_DIGEST_DOMAIN = "receiz.mcp-operation-plan.v125";
export const RECEIZ_CURRENT_MCP_ATTEMPT_DIGEST_DOMAIN = "receiz.mcp-operation-attempt.v125";
export const RECEIZ_CURRENT_MCP_RESULT_SCHEMA = "receiz.mcp.operation-result.v125";
export const RECEIZ_HISTORICAL_RECORD_SEAL_MCP_RESULT_SCHEMA = "receiz.mcp.operation-result.v112";
export const RECEIZ_CURRENT_MCP_CONSTITUTIONAL_PLAN_DIGEST_DOMAIN = "receiz.mcp-constitutional-plan.v125";
export const RECEIZ_CURRENT_MCP_CONSTITUTIONAL_ATTEMPT_DIGEST_DOMAIN = "receiz.mcp-constitutional-attempt.v125";
const HEX64 = /^[a-f0-9]{64}$/;
function uniqueSorted(values) {
    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
}
export function createReceizConstitutionalContext(input) {
    if (!HEX64.test(input.registryDigest) || input.applicableLaws.some((law) => !law) || input.allowedCommands.some((command) => !command))
        throw new Error("MCP_CONSTITUTIONAL_CONTEXT_INVALID");
    if (!input.stateMachine.states.includes(input.stateMachine.initial))
        throw new Error("MCP_STATE_MACHINE_INVALID");
    return {
        schema: "receiz.mcp.constitutional-context.v1",
        rulesetVersion: RECEIZ_CURRENT_MCP_RULESET_VERSION,
        registryDigest: input.registryDigest,
        applicableLaws: uniqueSorted(input.applicableLaws),
        authorityBoundary: structuredClone(input.authorityBoundary),
        stateMachine: structuredClone(input.stateMachine),
        allowedCommands: uniqueSorted(input.allowedCommands),
        forbiddenMutations: ["direct-state-write", "history-rewrite", "authority-bypass"],
        requiredVerification: ["typecheck", "law-coverage", "mutation-tests", "replay-equivalence", "compatibility", "mcp-conformance"],
        authority: { contextIsProofAuthority: false, strongerTruth: "sealed-receiz-proof-object" },
    };
}
export function scanReceizAuthorityBypass(source) {
    const checks = [
        { operation: "direct-state-write", expression: /(?:\.state\s*=|\bstate\.[A-Za-z0-9_]+\s*=|\bdb\.[A-Za-z0-9_.]+\.(?:update|set)\s*\(|\b(?:setXp|markAlive|changeOwner|grantReward)\s*\()/i },
        { operation: "history-rewrite", expression: /(?:delete|truncate|overwrite|rewrite).{0,32}(?:history|event|receipt|proof)/i },
        { operation: "authority-bypass", expression: /(?:skip|bypass|disable).{0,32}(?:law|authority|capability|verification)/i },
    ];
    const findings = checks.filter((check) => check.expression.test(source)).map((check) => ({ operation: check.operation, evidence: check.expression.source }));
    return { schema: "receiz.mcp.bypass-scan.v1", ok: findings.length === 0, findings };
}
function denial(operation, law, code, attemptedTransition, alternatives) {
    return {
        schema: RECEIZ_CURRENT_MCP_PLAN_SCHEMA,
        status: "denied",
        context: operation.context,
        denial: { law, code, attemptedTransition, affectedAsset: operation.affectedAsset ?? null, safeAlternatives: alternatives },
    };
}
function planBasis(operation) {
    return {
        schema: "receiz.mcp.operation-permit.v1",
        kind: operation.kind,
        registryDigest: operation.context.registryDigest,
        rulesetVersion: operation.context.rulesetVersion,
        command: operation.command ?? null,
        affectedAsset: operation.affectedAsset ?? null,
        proposedChange: operation.proposedChange,
        payload: operation.payload ?? null,
        applicableLaws: [...operation.context.applicableLaws],
        authorityBoundary: operation.context.authorityBoundary,
        requiredVerification: [...operation.context.requiredVerification],
    };
}
export async function planReceizConstitutionalOperation(operation) {
    if (operation.kind === "append-event" || operation.kind === "commit-atomic-projection") {
        return denial(operation, "receiz.v112.typed-artifact-transition-only", "V112_TYPED_ARTIFACT_TOOL_REQUIRED", operation.kind, ["receiz_artifact_append_plan", "receiz_artifact_transition_seal_and_stage", "receiz_artifact_transition_commit"]);
    }
    const scan = scanReceizAuthorityBypass(operation.proposedChange);
    if (!scan.ok)
        return denial(operation, "receiz.command-only-mutation", "AUTHORITY_BYPASS_FORBIDDEN", scan.findings[0].operation, ["command.simulate", "mcp.execute_command", "request-explicit-escalation"]);
    if (operation.kind === "execute-command" && (!operation.command || !operation.context.allowedCommands.includes(operation.command))) {
        return denial(operation, "receiz.allowed-commands-only", "COMMAND_NOT_ALLOWED", operation.command ?? "missing-command", ["command.scaffold", "command.simulate", "law.explain"]);
    }
    if (/dead\s*(?:→|->|to)\s*alive/i.test(operation.proposedChange) && operation.context.applicableLaws.includes("wilds.retirement.irreversible")) {
        return denial(operation, "wilds.retirement.irreversible", "RETIREMENT_IS_FINAL", "dead → alive", ["memorialize", "retire", "create-descendant"]);
    }
    const planIdentity = authorityDigest("plan", RECEIZ_CURRENT_MCP_CONSTITUTIONAL_PLAN_DIGEST_DOMAIN, planBasis(operation));
    const attemptNonce = randomUUID();
    return {
        schema: RECEIZ_CURRENT_MCP_PLAN_SCHEMA,
        status: "permitted",
        planDigest: planIdentity,
        planIdentity,
        attemptNonce,
        confirmationDigest: authorityDigest("confirmation", RECEIZ_CURRENT_MCP_CONSTITUTIONAL_ATTEMPT_DIGEST_DOMAIN, {
            planIdentity,
            attemptNonce,
        }),
        confirmationRequired: true,
        operation: structuredClone(operation),
        context: operation.context,
        requiredEvidence: operation.context.requiredVerification,
        writesPerformed: 0,
    };
}
export function createReceizConstitutionalRuntime(options) {
    const attemptStatus = new Map();
    const activeByPlanIdentity = new Map();
    return {
        context: options.context,
        async plan(input) {
            const candidate = await planReceizConstitutionalOperation({ ...input, context: options.context });
            if (candidate.status === "denied")
                return candidate;
            const active = activeByPlanIdentity.get(candidate.planIdentity);
            if (active?.status === "permitted" && attemptStatus.get(active.confirmationDigest) === "planned")
                return active;
            attemptStatus.set(candidate.confirmationDigest, "planned");
            activeByPlanIdentity.set(candidate.planIdentity, candidate);
            return candidate;
        },
        async execute(plan, confirmation) {
            if (plan.status !== "permitted")
                throw new Error("MCP_PERMIT_DENIED");
            const recomputedIdentity = authorityDigest("plan", RECEIZ_CURRENT_MCP_CONSTITUTIONAL_PLAN_DIGEST_DOMAIN, planBasis(plan.operation));
            const recomputedConfirmation = authorityDigest("confirmation", RECEIZ_CURRENT_MCP_CONSTITUTIONAL_ATTEMPT_DIGEST_DOMAIN, {
                planIdentity: recomputedIdentity,
                attemptNonce: plan.attemptNonce,
            });
            if (confirmation !== plan.confirmationDigest
                || recomputedIdentity !== plan.planIdentity
                || plan.planDigest !== plan.planIdentity
                || recomputedConfirmation !== plan.confirmationDigest)
                throw new Error("MCP_PERMIT_CONFIRMATION_INVALID");
            if (attemptStatus.get(plan.confirmationDigest) !== "planned")
                throw new Error("MCP_PERMIT_ALREADY_CONSUMED");
            attemptStatus.set(plan.confirmationDigest, "executing");
            try {
                const result = await options.executor(plan.operation);
                attemptStatus.set(plan.confirmationDigest, "committed");
                return { schema: "receiz.mcp.operation-result.v1", planDigest: plan.planDigest, planIdentity: plan.planIdentity, confirmationDigest: plan.confirmationDigest, result, context: options.context };
            }
            catch (error) {
                attemptStatus.set(plan.confirmationDigest, "failed");
                throw error;
            }
        },
    };
}
//# sourceMappingURL=constitutional.js.map