What America Trusts: How Article VI Assembles the Supreme Order

Starting question

How does a connected republic determine which obligations survived the transition, which norms possess supreme authority, and who must support that order?

The complete research foundation for this public adaptation is available on Zenodo: Code Constitution.

America after connection

In the first publication of the cycle, America appeared on the Death Stranding map through a sequence of local acts of consent. We reached a new node, restored communication, fulfilled the conditions of connection, and watched another area enter the UCA. Article VII allowed us to turn that experience into a bootstrap protocol: an artifact, nine ratifications, an established scope, and a transition to operating institutions.

Once connected, the terminal changed state. An isolated point gained access to the shared network, data, and infrastructure. Along with those capabilities came a less cinematic question: which messages belong to the common order, which version should be trusted, and whose instruction carries authority? A network can deliver a packet. Trust determines why its contents become a basis for action.

The distinction is especially visible in a distributed system. Several nodes may store different copies of the same document. A local administration may issue its own rule. An old obligation may survive the replacement of the entire internal architecture. A person may gain technical access to a critical component before the system can explain the provenance of that authority. After bootstrap, the republic needs a common method for distinguishing a canonical corpus, a derivative norm, a local decision, a valid obligation, and the mere technical ability to force an outcome.

Article VI of the United States Constitution performs precisely this work. It receives the system from Article VII and establishes its first relationships of trust. America has entered the network. The network must now learn its own order.

Three clauses, four software duties

Article VI consists of three clauses. The first preserves the validity of debts and engagements incurred before adoption of the Constitution. The second names the Constitution, federal laws made in pursuance of it, and treaties made under the authority of the United States as the supreme law of the land; judges in every state are bound by that order when state law conflicts with it. The third binds federal and state officeholders by oath or affirmation to support the Constitution and prohibits a religious test for federal office or public trust. The full text is available in the United States National Archives transcript.

In the software model, the three clauses produce four duties:

This creates rootOfTrust(), the second build of our constitutional prototype. In computer security, a root of trust is a starting point upon which a system relies when constructing a subsequent chain of verification. NIST describes roots of trust as reliable foundations for critical security functions. Our adaptation transfers the structure: the revision established under Article VII becomes the starting point, and every derivative act must show a path back to it.

The constitutional root of trust retains its normative character. A cryptographic digest can confirm that the bytes have not changed. Ratification gives the document its constituent foundation. A registry of powers shows which derivative actions the revision authorizes. Each layer answers a different question, and their combination produces a verifiable chain.

flowchart TB
    A["Article VII: established revision"] --> B["Constitutional root of trust"]
    C["Prior obligations"] --> D["Validity and continuity check"]
    B --> E["Federal laws and treaties"]
    B --> F["Duty of a public role"]
    D --> G["Decision with provenance and trace"]
    E --> G
    F --> G

What survives architectural replacement

The first clause of Article VI looks modest and performs fundamental work. The new Constitution does not begin history from an empty disk. Debts and engagements incurred under the Confederation remain valid against the United States after the transition. Constitution Annotated connects the provision with the financial obligations of the prior order and the federal government’s later assumption of Confederation debts.

For software architecture, this produces a continuity rule. Replacing a kernel, organizational structure, or governance model preserves an obligation according to that obligation’s own basis. A contract with an external party, a compatibility promise, a duty to retain data, or an issued license continues until a proper act provides for its performance, replacement, or termination.

The rule protects the system from convenient amnesia. A team can rename a service, split a repository, change product ownership, and announce a “new platform.” The counterparty continues to remember the old promise with remarkable durability. Article VI offers an architecturally mature formula: internal transformation changes the bearer of performance, while the validity of the obligation follows from its own foundation.

The code therefore does not turn every old record into a valid debt. validBeforeAdoption represents validity that has already been established. The prototype carries forward a confirmed obligation and sends an unverified claim to a separate review. Continuity preserves a debt; it does not manufacture one from archival dust.

Supremacy that requires provenance

The second clause of Article VI contains one of the Constitution’s strongest formulas: the supreme Law of the Land. Its software adaptation demands particular care. The Constitution identifies as supreme federal laws made in Pursuance of the Constitution and treaties made under the Authority of the United States. The conditions form part of the chain of authority itself.

The source type therefore does not settle the conflict by itself. A federal file, a federal author, or a field named claimsSupremacy: true reports the provenance of a claim. Supreme force appears only after procedure and constitutional authority have been verified. The filename SUPREME_FINAL_FINAL.md vividly captures the editor’s mood; the status of the norm requires more tedious documentation.

The system also distinguishes supremacy from unlimited centralization. In a direct conflict, a valid federal norm displaces the conflicting portion of a state norm within their shared scope. The nonconflicting local portion remains effective. This solution supports a federal architecture: the common order provides compatibility, while the local node retains its own competence.

In constitutional law, federal preemption doctrine is considerably more complex than our first algorithm. The Library of Congress overview of the Supremacy Clause covers the development of judicial approaches to conflicts between federal and state law. In this publication, the code recognizes only the clearest case: two applicable prescriptions assign incompatible values to the same field within a shared scope. Other forms of conflict remain inputs for the future Article III judicial component.

flowchart TB
    A["Federal norm"] --> B{"Have source, procedure, and authority been verified?"}
    B -- "No" --> C["Claimed priority rejected"]
    B -- "Yes" --> D{"Is there a direct conflict in a shared scope?"}
    D -- "No" --> E["Both norms remain effective"]
    D -- "Yes" --> F["Only the conflicting part of state law is displaced"]

The oath as a bond between role and order

The third clause of Article VI extends the chain of trust from documents to people. Senators, representatives, members of state legislatures, and federal and state executive and judicial officers take an oath or affirmation to support the Constitution. The choice between oath and affirmation is built into the text. The system requires a commitment and permits two forms of undertaking it.

In the software model, the holder of a role identifies the exact revision that they undertake to support. The record does not turn the person into an advocate for every current policy. It binds the exercise of office to the operating constitutional order, including its authorized methods of dispute and change. Loyalty to procedure remains compatible with criticism of a result.

The final formula prohibits a religious Test as a qualification for federal office or public trust. A functional qualification may assess a person’s ability to perform the role and manage its risks. Doctrinal affiliation does not become a credential. Library of Congress materials show that religious tests for public service had a concrete historical context and that Article VI established a federal prohibition.

The textual scope of that prohibition requires precision. The oath formula expressly covers federal and state officeholders. The Religious Test Clause applies to an office or public trust “under the United States.” The prototype therefore rejects a federal test and refers a state test for broader constitutional review. Modern limits on states also rely on later amendments and judicial doctrine; our function preserves the boundary of the original article.

flowchart TB
    A["Appointment to a public role"] --> B{"Oath or affirmation?"}
    B -- "Yes" --> C["Role bound to an exact constitutional revision"]
    B -- "No" --> D["Role activation blocked"]
    E["Religious test for a federal role"] --> F["Qualification rejected"]

An executable root of trust

The second build preserves the pure functions of the first publication and adds an explainable decision. Every result contains a trace, a reference to the clause from which the behavior was derived. The code receives no universal isConstitutional() function. It checks a limited set of machine-representable conditions and leaves its semantic premises visible.

The research project Code Constitution develops this material across six domains: the official corpus, the validity of written and unwritten norms, conflict resolution, technical enforcement, continuity of obligations, and the duty attached to a role. The public prototype returns to the three original clauses of Article VI and uses the extended model as a tracing instrument. The reader can therefore distinguish a direct rule of the United States Constitution, a necessary technical deduction, and an added engineering choice.

The complete prototype module follows. It uses standard JavaScript and runs in an ESM environment without external dependencies.

export const ARTICLE_VI = Object.freeze({
	id: 'US-CONST:VI',
	clauses: Object.freeze({
		continuity: 'US-CONST:VI.1',
		supremacy: 'US-CONST:VI.2',
		office: 'US-CONST:VI.3',
	}),
});

function freezeList(items) {
	return Object.freeze(items.map((item) => Object.freeze({ ...item })));
}

function requireString(value, field) {
	if (typeof value !== 'string' || value.length === 0) {
		throw new TypeError(`${field} must be a non-empty string`);
	}
}

function scopesOverlap(left, right) {
	return left.includes('*') || right.includes('*') || left.some((value) => right.includes(value));
}

export function createRootOfTrust({ constitution, authorityGrants }) {
	requireString(constitution.id, 'constitution.id');
	requireString(constitution.digest, 'constitution.digest');

	if (constitution.established !== true) {
		throw new Error('The constitutional revision has not been established');
	}

	return Object.freeze({
		constitutionId: constitution.id,
		digest: constitution.digest,
		authorityGrants: Object.freeze([...new Set(authorityGrants)]),
		establishedBy: constitution.establishedBy,
		trace: Object.freeze(['US-CONST:VII', ARTICLE_VI.id]),
	});
}

export function continuePriorObligations(obligations) {
	return freezeList(
		obligations.map((obligation) => ({
			...obligation,
			status: obligation.validBeforeAdoption === true ? 'continued' : 'requires-validation',
			basis: obligation.validBeforeAdoption === true ? ARTICLE_VI.clauses.continuity : null,
		})),
	);
}

export function validateSupremeNorm(norm, root) {
	if (norm.kind === 'constitution') {
		const eligible = norm.id === root.constitutionId && norm.digest === root.digest;

		return Object.freeze({
			eligible,
			reason: eligible ? 'canonical-constitution' : 'untrusted-revision',
			trace: Object.freeze([ARTICLE_VI.clauses.supremacy]),
		});
	}

	if (norm.kind === 'federal-law') {
		const eligible =
			norm.procedureVerified === true &&
			norm.madeInPursuanceOf === root.constitutionId &&
			root.authorityGrants.includes(norm.authorityGrant);

		return Object.freeze({
			eligible,
			reason: eligible ? 'law-made-in-pursuance' : 'pursuance-or-authority-not-proven',
			trace: Object.freeze([ARTICLE_VI.clauses.supremacy]),
		});
	}

	if (norm.kind === 'treaty') {
		const eligible = norm.procedureVerified === true && norm.underAuthorityOf === 'United States';

		return Object.freeze({
			eligible,
			reason: eligible ? 'treaty-under-us-authority' : 'federal-authority-not-proven',
			trace: Object.freeze([ARTICLE_VI.clauses.supremacy]),
		});
	}

	return Object.freeze({
		eligible: false,
		reason: 'source-class-is-not-supreme',
		trace: Object.freeze([ARTICLE_VI.clauses.supremacy]),
	});
}

export function resolveSupremacy({ root, federalNorm, stateNorm }) {
	const federalStatus = validateSupremeNorm(federalNorm, root);

	if (!federalStatus.eligible) {
		return Object.freeze({
			outcome: 'federal-claim-rejected',
			effective: Object.freeze([stateNorm.id]),
			displaced: Object.freeze([]),
			reason: federalStatus.reason,
			trace: federalStatus.trace,
		});
	}

	const sameField = federalNorm.claim.key === stateNorm.claim.key;
	const incompatibleValue = federalNorm.claim.value !== stateNorm.claim.value;
	const overlappingScope = scopesOverlap(federalNorm.appliesIn, stateNorm.appliesIn);

	if (!(sameField && incompatibleValue && overlappingScope)) {
		return Object.freeze({
			outcome: 'compatible',
			effective: Object.freeze([federalNorm.id, stateNorm.id]),
			displaced: Object.freeze([]),
			reason: 'no-direct-conflict-in-shared-scope',
			trace: Object.freeze([ARTICLE_VI.clauses.supremacy]),
		});
	}

	return Object.freeze({
		outcome: 'state-provision-displaced',
		effective: Object.freeze([federalNorm.id]),
		displaced: Object.freeze([stateNorm.id]),
		onlyWithin: Object.freeze({
			key: federalNorm.claim.key,
			scope: Object.freeze([...stateNorm.appliesIn]),
		}),
		boundDecisionMakers: Object.freeze(['state-judges']),
		reason: 'direct-conflict-with-eligible-supreme-norm',
		trace: Object.freeze([ARTICLE_VI.clauses.supremacy]),
	});
}

export function bindOfficeHolder({ root, appointment, commitment }) {
	if (!['federal', 'state'].includes(appointment.jurisdiction)) {
		throw new TypeError('Unsupported office jurisdiction');
	}

	if (appointment.jurisdiction === 'federal' && appointment.religiousTest !== undefined) {
		throw new Error('A religious test cannot qualify a federal office');
	}

	if (!['oath', 'affirmation'].includes(commitment.mode)) {
		throw new TypeError('Commitment must be an oath or affirmation');
	}

	if (commitment.supports !== root.constitutionId) {
		throw new Error('Commitment refers to a different constitutional revision');
	}

	return Object.freeze({
		officeId: appointment.id,
		holderId: appointment.holderId,
		status: 'bound-to-support',
		commitmentMode: commitment.mode,
		religiousTestReview:
			appointment.jurisdiction === 'state' && appointment.religiousTest !== undefined
				? 'outside-article-vi-federal-ban; broader-review-required'
				: 'not-present',
		trace: Object.freeze([ARTICLE_VI.clauses.office]),
	});
}

createRootOfTrust() connects the second publication to the first: only a revision established under Article VII can become the root. continuePriorObligations() preserves confirmed continuity. validateSupremeNorm() checks the source class and path of authority. resolveSupremacy() handles a direct conflict and limits displacement to the shared scope. bindOfficeHolder() binds a role to an exact revision, accepts an oath or affirmation, and preserves the textual boundary of the Religious Test Clause.

The model uses a digest field without pretending that a string constitutes cryptographic attestation. In an operating system, the digest would be computed from the canonical artifact and attested by a trusted publication process. Here it serves as an observable identifier of the exact revision. Article VII supplies the revision’s authority to exist; a technical process verifies the integrity of its representation.

WARDEN: ten ways to doubt correctly

In the second publication, WARDEN tests a chain of decisions rather than a single threshold function. Every scenario declares the source of its invariant. Each test checks observable behavior, while the reader can see where literal text ends and an engineering decision begins.

flowchart TB
    A["Text of Article VI"] --> C["Normative invariants"]
    B["Engineering assumptions"] --> C
    C --> D["Executable module"]
    D --> E["10 WARDEN scenarios"]
    E --> F{"Has the decision’s provenance been preserved?"}
    F -- "Yes" --> G["Model admitted to the next build"]
    F -- "No" --> H["Code or interpretation returned for review"]

The complete battery uses the standard node:test and assert modules:

import test from 'node:test';
import assert from 'node:assert/strict';

import {
	ARTICLE_VI,
	bindOfficeHolder,
	continuePriorObligations,
	createRootOfTrust,
	resolveSupremacy,
	validateSupremeNorm,
} from './article-vi.js';

function wardenTest(name, sourceClauses, scenario) {
	test(name, () => {
		assert.ok(sourceClauses.length > 0, 'WARDEN needs a declared source');
		scenario();
	});
}

const constitution = Object.freeze({
	id: 'us-constitution:1787',
	digest: 'sha256:attested-article-vii-revision',
	established: true,
	establishedBy: 'article-vii-ratification',
});

const root = createRootOfTrust({
	constitution,
	authorityGrants: ['I.8:interstate-commerce'],
});

const validFederalLaw = Object.freeze({
	id: 'federal:manifest-v2',
	kind: 'federal-law',
	procedureVerified: true,
	madeInPursuanceOf: constitution.id,
	authorityGrant: 'I.8:interstate-commerce',
	appliesIn: ['*'],
	claim: Object.freeze({ key: 'interstate.manifest.version', value: 2 }),
});

const virginiaLaw = Object.freeze({
	id: 'virginia:manifest-v1',
	kind: 'state-law',
	appliesIn: ['Virginia'],
	claim: Object.freeze({ key: 'interstate.manifest.version', value: 1 }),
});

wardenTest(
	'an unestablished revision cannot become the root of trust',
	['US-CONST:VII', ARTICLE_VI.id],
	() => {
		assert.throws(
			() =>
				createRootOfTrust({
					constitution: { ...constitution, established: false },
					authorityGrants: [],
				}),
			/has not been established/,
		);
	},
);

wardenTest(
	'a valid prior obligation survives architectural replacement',
	[ARTICLE_VI.clauses.continuity],
	() => {
		const [validDebt, unverifiedClaim] = continuePriorObligations([
			{ id: 'confederation:debt-1', validBeforeAdoption: true },
			{ id: 'confederation:claim-2', validBeforeAdoption: false },
		]);

		assert.equal(validDebt.status, 'continued');
		assert.equal(unverifiedClaim.status, 'requires-validation');
	},
);

wardenTest('a self-declared federal priority is rejected', [ARTICLE_VI.clauses.supremacy], () => {
	const result = resolveSupremacy({
		root,
		federalNorm: {
			...validFederalLaw,
			procedureVerified: false,
			claimsSupremacy: true,
		},
		stateNorm: virginiaLaw,
	});

	assert.equal(result.outcome, 'federal-claim-rejected');
	assert.deepEqual(result.effective, [virginiaLaw.id]);
});

wardenTest(
	'a valid federal law displaces a direct conflict',
	[ARTICLE_VI.clauses.supremacy],
	() => {
		const result = resolveSupremacy({
			root,
			federalNorm: validFederalLaw,
			stateNorm: virginiaLaw,
		});

		assert.equal(result.outcome, 'state-provision-displaced');
		assert.deepEqual(result.displaced, [virginiaLaw.id]);
		assert.equal(result.onlyWithin.key, 'interstate.manifest.version');
		assert.deepEqual(result.boundDecisionMakers, ['state-judges']);
	},
);

wardenTest('a nonconflicting state rule remains effective', [ARTICLE_VI.clauses.supremacy], () => {
	const result = resolveSupremacy({
		root,
		federalNorm: validFederalLaw,
		stateNorm: {
			...virginiaLaw,
			id: 'virginia:local-archive',
			claim: { key: 'local.archive.period', value: '10-years' },
		},
	});

	assert.equal(result.outcome, 'compatible');
	assert.equal(result.effective.length, 2);
});

wardenTest(
	'an oath and an affirmation equally bind an officeholder',
	[ARTICLE_VI.clauses.office],
	() => {
		for (const mode of ['oath', 'affirmation']) {
			const result = bindOfficeHolder({
				root,
				appointment: {
					id: `state-judge:${mode}`,
					holderId: `holder:${mode}`,
					jurisdiction: 'state',
				},
				commitment: { mode, supports: constitution.id },
			});

			assert.equal(result.status, 'bound-to-support');
			assert.equal(result.commitmentMode, mode);
		}
	},
);

wardenTest('a religious test cannot qualify a federal role', [ARTICLE_VI.clauses.office], () => {
	assert.throws(
		() =>
			bindOfficeHolder({
				root,
				appointment: {
					id: 'federal:auditor',
					holderId: 'person:1',
					jurisdiction: 'federal',
					religiousTest: 'declared-creed',
				},
				commitment: { mode: 'affirmation', supports: constitution.id },
			}),
		/religious test/,
	);
});

wardenTest(
	'a state religious test is referred for broader review',
	[ARTICLE_VI.clauses.office],
	() => {
		const result = bindOfficeHolder({
			root,
			appointment: {
				id: 'state:auditor',
				holderId: 'person:2',
				jurisdiction: 'state',
				religiousTest: 'declared-creed',
			},
			commitment: { mode: 'oath', supports: constitution.id },
		});

		assert.match(result.religiousTestReview, /broader-review-required/);
	},
);

wardenTest(
	'a commitment to support the order names an exact revision',
	[ARTICLE_VI.clauses.office],
	() => {
		assert.throws(
			() =>
				bindOfficeHolder({
					root,
					appointment: {
						id: 'federal:clerk',
						holderId: 'person:3',
						jurisdiction: 'federal',
					},
					commitment: { mode: 'oath', supports: 'unknown-revision' },
				}),
			/different constitutional revision/,
		);
	},
);

wardenTest(
	'the canonical text is recognized by identifier and digest',
	[ARTICLE_VI.clauses.supremacy],
	() => {
		const accepted = validateSupremeNorm(
			{ kind: 'constitution', id: constitution.id, digest: constitution.digest },
			root,
		);
		const altered = validateSupremeNorm(
			{ kind: 'constitution', id: constitution.id, digest: 'sha256:altered' },
			root,
		);

		assert.equal(accepted.eligible, true);
		assert.equal(altered.eligible, false);
	},
);

The executable version passes all ten scenarios with node --test. The battery checks four groups of invariants:

The most important negative scenario is claimsSupremacy: true. The program deliberately ignores it when procedure or authority has not been verified. An act’s self-description remains data and does not create priority. The architecture gains a defense against normative privilege escalation.

The state religious-test scenario produces a different kind of result. The prototype does not declare the test permissible. It stops the automatic decision and reports that Article VI’s literal federal prohibition has reached its boundary and that the issue requires the broader constitutional corpus. Stopping is itself complete system behavior. The machine carries the dispute to the edge of its own authority and refrains from composing a missing amendment on the fly.

What Article VI gives software architecture

The second article in the cycle leaves five practical conclusions.

The root of trust continues the establishment protocol. The canonical revision receives initial trust through an established procedure. An identifier, digest, and publication location help authenticate the artifact; the constituent foundation gives it authority.

Obligations survive internal transformation. An architectural transition includes an inventory of valid debts, contracts, licenses, and promises. The successor inherits those obligations along with the system.

Supremacy depends on provenance. A derivative norm identifies its source, procedure, subject-matter authority, and scope. Wide distribution and technical enforcement are evidence of a factual condition; they do not create authority by themselves.

Conflict is resolved within proven boundaries. The higher order displaces the incompatible portion. A local rule keeps its nonconflicting scope, allowing a federal system to provide compatibility without automatically absorbing its nodes.

A public role is bound to the order while freedom to criticize remains. An oath or affirmation records a duty to support the operating revision through the procedures it provides. Doctrinal affiliation does not substitute for functional qualification.

These properties transfer well to configuration governance, supply chains, policy registries, distributed products, and projects with several autonomous teams. Article VI forces the system to answer “why is this in force?” for every rule, obligation, and privileged role. That question is particularly useful in a mature repository, where a historical accident has usually already acquired a filename, an owner, and the emotional support of half the CI pipeline.

Where the second experiment ends

Article VI is more difficult than Article VII because its conditions carry substantive meaning. A machine can easily compare identifiers, digests, scopes, and values. The concepts “in Pursuance of the Constitution,” “under the Authority of the United States,” “valid obligation,” and “support of the Constitution” require an established fact and interpretation.

Our prototype receives some of those conclusions as input data. procedureVerified reports the result of a separate procedural check. authorityGrant identifies a power that has already been recognized. validBeforeAdoption reports the established validity of a prior obligation. The code preserves the provenance of those claims and applies them consistently; it cannot yet prove each one independently.

The conflict algorithm is deliberately narrow as well. It sees two incompatible values assigned to one field in a shared scope. Actual constitutional law considers direct contradiction, the boundary of federal power, several forms of preemption, legislative intent, and judicial remedies. Those questions require Articles I and III, which do not yet exist in the operating build.

An oath creates an observable commitment and does not guarantee a person’s future conduct. A cryptographic digest confirms that a revision matches and does not prove that the revision is just. WARDEN verifies that the code conforms to the selected invariants and does not become the source of those invariants. Every boundary remains part of the model’s result.

The second experiment is therefore stronger than the first, and its self-assessment is more restrained. Article VI can indeed be adapted into software architecture as a chain of provenance, continuity, limited conflict resolution, and role binding. Complete execution depends on components that will appear later.

The eagle now has a root of trust and a decision log. The build has predictably fallen short of absolute knowledge of good and evil; for version two, that is more a sign of a healthy system than a marketing defect.

Conclusion

Article VII gave the republic its moment of establishment. Article VI gives the established system memory and an order of trust. Prior obligations cross the transition, the canonical revision becomes the starting point of verification, derivative norms prove the provenance of their authority, a direct conflict receives a bounded resolution, and a public role is bound to the Constitution through an oath or affirmation.

In code, the order becomes five functions, ten test scenarios, and an explicit trace for every result. The model can reject an altered revision, self-declared priority, and a prohibited federal qualification. It can also stop at a question for which the original article is insufficient. This is an important extension of the experiment: the software form preserves both a rule and the boundary of its own decision.

The next publication turns to Article V. The system now has an activation point and a root of trust. It will need a safe method for changing its own kernel, preserving continuity, and carrying a new revision through an operating federation.

Continue the research with AI

The site renders this section from the independent question set constitution-runtime.article-vi.root-of-trust, stored in the companion catalog constitution-runtime-02-article-vi-questions.yaml. Each question contains its own constitutional subject, software object, and interpretive frame, so it can be reused in another publication or conversational path without copying this article.

The recommended route is connection → continuity → root of trust → supremacy → public role → WARDEN → limits of the model. The AI answer contract, branch triggers, visual references, and localized prompts are defined in the question catalog.

Publication information

Authors: Sam Starling, Oksana Dubinetska
Project context: Zhovten Games / IRONCREED
Complete research source: Code Constitution — DOI 10.5281/zenodo.21894242
Research repository: FOP-Oksana-Dubinetska/code-constitution
Historical and technical materials: text of the United States Constitution; overview of Article VI; Debts and Engagements Clause; Supremacy Clause; oaths of office; history of the Religious Test Clause; NIST: roots of trust
Related publication: “Connect America: How Article VII Bootstraps a Republic”
Next publication: Article V in the “Constitution That Runs” cycle
Publication revision: 0.2 · 13 August 2026