Update America: How Article V Changes the Constitutional Kernel

Starting question

How can a system already in force change its own root of trust while preserving the provenance of authority, the exactness of the new revision, and a controlled transition?

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

A patch that must first obtain permission to install

In the first publication, America appeared on the Death Stranding map as individual nodes joined the UCA. Article VII turned that experience into bootstrap(): thirteen potential participants, nine ratifications, and the establishment of a common system among the consenting states. In the second publication, Article VI added rootOfTrust(): a canonical revision, continuity of obligations, verification of the provenance of federal priority, and a connection between public roles and the Constitution.

Over time, a working network encounters a new problem. Its foundational document needs to change, yet the authority to change that document comes from the document itself. The current revision must authorize a procedure capable of creating the next revision and replacing the current root of trust. Ordinary administrative access expresses the factual ability to write new bytes. A constitutional update requires demonstrated authority to make those bytes part of the supreme order.

Game updates usually arrive from outside the game world. The platform displays the download size, a change log, and an install button. The player may consent, postpone the process, or discover that the choice has already been helpfully made on their behalf. A republic imposes a more demanding condition on an update: no one within the operating order receives a permanent Deploy Constitution button.

Article V constructs a self-amendment procedure without a single owner of the kernel. It separates proposal from ratification, provides an ordinary and a reserve route of initiative, assigns Congress the choice of ratification mode, establishes elevated thresholds, and protects particular provisions with additional conditions. In software form, this mechanism becomes upgradeKernel()—an update that first proves its right to exist, then changes the official corpus, and only afterward passes through the operating runtime.

The third build

The reverse route through the cycle has reached the first operation capable of modifying components that already exist.

The third build preserves the results of the earlier parts and adds seven objects:

1. an immutable source—the constitutional root currently in force;
2. the exact text of the proposed amendment;
3. a record of the proper proposal route;
4. a ratification mode selected in advance;
5. a log of authenticated state decisions;
6. a new root of trust with a complete line of provenance;
7. a transition state between the normative revision and the actual runtime.

For the first time, this set makes the model genuinely temporal. Earlier, a function answered whether a document was in force and why a particular norm received priority. Now the system stores a sequence of revisions, the moment when the operating foundation changes, a period of coexistence, and the consequences of a failed deployment.

One sentence with four gates

Article V of the original Constitution consists of one long sentence. Its central formula states that an amendment becomes valid as part of the Constitution “when ratified by … three fourths of the several States.” The complete text is preserved in the United States National Archives transcript.

In a software reading, the sentence forms four consecutive gates:

Official attestation and technical migration occur after these gates. The operating administrative procedure assigns publication and certification of the result to the Archivist of the United States. The project’s engineering model adds a transition plan, updates to derivative rules, data, permissions, and automated constraints. These two layers receive distinct names instead of disappearing inside the word “adopted.”

Two proposal routes

The first route runs through Congress. A proposal receives two thirds of the votes in the House of Representatives and two thirds in the Senate. In constitutional practice, this threshold is calculated from the members present when a quorum exists; Constitution Annotated records that form. With the current chambers at full membership, the test model yields 290 votes out of 435 and 67 out of 100. The real calculation depends on the number present.

The President has no constitutional role in this route. A joint resolution proposing an amendment goes to the states without presidential signature or approval. The National Archives explicitly distinguishes the Article V process from ordinary legislation. The code preserves the distinction in presidentialApproval: "not-part-of-article-v-proposal". Even a positive or negative presidential position remains a political fact rather than a gate in the procedure.

The second route begins with applications from the legislatures of two thirds of the states. Once the threshold is reached, Congress calls a convention for proposing amendments. With fifty states, the threshold is thirty-four unique applications. None of the twenty-seven amendments now in force was proposed in this manner; the National Archives notes that all of them proceeded through Congress.

The reserve route performs an important architectural function. An institution whose powers are to be changed may lose its monopoly over placing the issue on the agenda. Two thirds of the states can open an alternative entrance. Yet Article V says almost nothing about the convention’s internal procedure: composition, voting, subject-matter limits, and certification of a proposal require separate legal and organizational decisions. The prototype accepts an authenticated convention result as an input and explicitly returns unresolvedProtocol. It preserves the gap instead of cheerfully generating a constitutional procedure that the text does not supply.

flowchart TB
    A["Constitutional root in force"] --> B{"Proposal route"}
    B --> C["Two thirds of the House and Senate"]
    B --> D["Applications from two thirds of state legislatures"]
    D --> E["Congress calls a convention"]
    E --> F["Convention proposes exact text"]
    C --> G["Proposed amendment"]
    F --> G
    G --> H{"Selected ratification mode"}
    H --> I["State legislatures"]
    H --> J["State conventions"]

One revision and one mode

A ratifying state must assent to the same proposal that passed through the constitutional initiative process. The software model therefore creates a digest from the exact text, the source root, the proposal date, the declared effects, the ratification mode, and the transition plan. Any substantive change creates a different artifact and requires a new confirmation.

The digest solves a limited technical problem. It demonstrates equality of the serialized object and supports tracing. A cryptographic signature, the authenticity of a paper instrument, the competence of the signatory, and the legal validity of the decision remain separate checks. A hash can detect a different text; public authority still does not grow out of an attractive hexadecimal string.

Congress also chooses one of two ratification modes: decisions by state legislatures or decisions by specially convened state conventions. The current model rejects a mixed count. The Twenty-first Amendment provides the historically important example of the second mode: it remains the only amendment ratified by state conventions, as the National Archives virtual exhibit confirms.

In the project’s Code Constitution, the proposal’s exactness is reinforced by a transition plan. It lists affected derivative norms, roles, permissions, data, tests, completion criteria, and a safe state. The original Article V does not expressly require such a document. This is an engineering extension of the model: participants can evaluate the normative change together with the material cost of implementing it.

The thirty-eighth state

With fifty states, three fourths means thirty-eight. Thirty-seven authenticated ratifications leave the previous revision in force. The thirty-eighth makes the proposal part of the Constitution, provided that Article V’s special constraints have been satisfied.

The National Archives describes the moment directly: a proposed amendment becomes part of the Constitution immediately after ratification by three fourths of the states. Once the required number of properly authenticated instruments has arrived, the Office of the Federal Register prepares a proclamation and the Archivist certifies the result. 1 U.S.C. § 106b provides for publication of the amendment together with a certificate.

The prototype preserves this sequence in two fields. constitutionalStatus: "part-of-constitution" appears when the threshold is reached. attestationStatus: "pending-official-notice" shows that the official publication process is still under way. attestAndIntegrate() creates a verifiable new root and an official-notice record, with createsValidity set to false.

stateDiagram-v2
    [*] --> Draft
    state "Exact draft" as Draft
    state "Properly proposed" as Proposed
    state "State ratifications" as Ratifying
    state "Part of the Constitution" as Valid
    state "Official attestation" as Attested
    state "Runtime transition" as Transition
    state "New revision running" as Aligned
    state "Safe state" as Safe

    Draft --> Proposed: proposal threshold reached
    Proposed --> Ratifying: mode selected
    Ratifying --> Valid: three fourths of states
    Valid --> Attested: review and publication
    Attested --> Transition: migration begins
    Transition --> Aligned: all steps completed
    Transition --> Safe: transition failure
    Safe --> Transition: recovery

The Twenty-seventh Amendment gives this model a rare historical stress test. Congress proposed it in 1789, and the required threshold was reached in 1992—almost 203 years later. The National Archives preserves both dates in the history of its certification. The prototype therefore does not invent an unspecified expiration date. Questions concerning an expressly imposed deadline, the contemporaneity of consent, and authority to assess a rescission exist in separate legal doctrine; the automated model records them as external conditions or disputes.

Official practice receives instruments that reject or rescind an earlier ratification, but the Archivist does not resolve the substance of those disputes. In the code, a rescind event moves a state decision into requires-review and excludes it from automatic counting until an external decision is supplied. This conservative stop remains observable and does not convert a contested act into a silent plus or minus inside an array.

Two protected regions of the kernel

The concluding portion of Article V establishes two special limits. The first was temporary: before 1808, no amendment could affect the first and fourth clauses of Article I, Section 9. One preserved, until the specified date, a federal limitation on prohibiting the importation of enslaved people; the other concerned direct taxation. Constitutional architecture received a temporary write lock around a political compromise in which human bodies entered the system as objects of trade. Formal precision here served barbarism with a quality of recordkeeping that an operations department might envy.

The temporary limit expired at the start of 1808. WARDEN nevertheless tests it against historical dates: a proposal dated December 31, 1807, is blocked, while one dated January 1, 1808, proceeds to further evaluation. This preserves the semantics of the original text without pretending that the long-expired protection remains active in 2026.

The second limit remains in the operative text. A state cannot be deprived of equal suffrage in the Senate without its consent. The general three-fourths threshold remains insufficient when the affected state has not agreed. The code collects special consent separately and also treats the affected state’s own ratification as consent. The latter is an explicit engineering interpretation; classifying a real amendment requires legal analysis of its substance.

flowchart TB
    A["Amendment reached the ratification threshold"] --> B{"Does it affect an entrenched provision?"}
    B -- "No" --> C["Amendment enters the Constitution"]
    B -- "Protection until 1808" --> D{"Date before 1808?"}
    D -- "Yes" --> E["Change blocked"]
    D -- "No" --> C
    B -- "Equal suffrage in the Senate" --> F{"Consent of affected state?"}
    F -- "Yes" --> C
    F -- "No" --> E

An adopted norm and an unfinished transition

Article V defines the appearance of a valid amendment. It does not describe replacing configuration, reworking statutes, training officeholders, migrating data, or disabling automated mechanisms built on the former foundation. Those actions belong to the runtime and take shape through the development performed in Code Constitution.

The prototype distinguishes three moments:

After a successful transition, runtimeRevision matches the new constitutionalRoot. After a failure, the system enters a safe state named in advance. The example uses read-only-compatibility: disputed operations stop, evidence is preserved, and recovery continues under an explicit plan.

A technical rollback can restore a previous binary artifact or configuration. It cannot repeal a ratified amendment. silentConstitutionalRollback: false turns this limit into a testable invariant. The new norm’s future requires completion of the transition, adoption of another amendment, or a separate constituent decision. A failed deployment reports a defect in implementation; it receives no git revert authority over the Constitution.

flowchart LR
    A["Old normative revision"] --> B["Ratified amendment"]
    B --> C["New constitutional root"]
    C --> D{"Runtime migration"}
    D -- "Success" --> E["Norm and execution aligned"]
    D -- "Failure" --> F["Safe state"]
    F --> G["Restore transition or adopt another amendment"]
    G --> D

The executable upgradeKernel() protocol

The third build is written for Node.js in ESM format and uses only the standard node:crypto module. The code contains the complete path from an exact proposal to the runtime transition. Unlike the earlier parts, a single function can no longer express the whole mechanism without losing provenance. The protocol is divided into stages, and upgradeKernel() coordinates them.

The root created in the second publication already contains constitutionId, digest, and authorityGrants, but it did not yet have a separate status field. The validator accepts that format directly, carries the authority registry into the next revision, and rejects a root explicitly marked as no longer in force. A semantic change to the powers themselves will require a separate build of the consolidated corpus; the present prototype preserves them unchanged. The third build thus develops the earlier model through a compatible contract instead of an unannounced rewrite of its output.

<!-- Complete executable module; synchronized with the WARDEN suite in revision 0.1. -->

import { createHash } from 'node:crypto';

export const ARTICLE_V = Object.freeze({
	id: 'US-CONST:V',
	rules: Object.freeze({
		proposal: 'US-CONST:V:proposal',
		ratification: 'US-CONST:V:ratification',
		entrenchment1808: 'US-CONST:V:entrenchment-1808',
		equalSuffrage: 'US-CONST:V:equal-suffrage',
		transition: 'KC:V.5',
	}),
});

const RATIFICATION_MODES = Object.freeze(['state-legislatures', 'state-conventions']);

function deepFreeze(value) {
	if (value && typeof value === 'object' && !Object.isFrozen(value)) {
		for (const nested of Object.values(value)) {
			deepFreeze(nested);
		}

		Object.freeze(value);
	}

	return value;
}

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

function requireUniqueStrings(values, field) {
	if (!Array.isArray(values) || values.length === 0) {
		throw new TypeError(`${field} must be a non-empty array`);
	}

	for (const value of values) {
		requireNonEmptyString(value, field);
	}

	if (new Set(values).size !== values.length) {
		throw new TypeError(`${field} must contain unique values`);
	}
}

function canonicalJson(value) {
	if (Array.isArray(value)) {
		return `[${value.map((item) => canonicalJson(item)).join(',')}]`;
	}

	if (value && typeof value === 'object') {
		return `{${Object.keys(value)
			.sort()
			.map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`)
			.join(',')}}`;
	}

	return JSON.stringify(value);
}

export function digest(value) {
	return `sha256:${createHash('sha256').update(canonicalJson(value)).digest('hex')}`;
}

export function requiredVotes(total, numerator, denominator) {
	if (
		!Number.isInteger(total) ||
		total < 1 ||
		!Number.isInteger(numerator) ||
		!Number.isInteger(denominator) ||
		numerator < 1 ||
		denominator < 1 ||
		numerator > denominator
	) {
		throw new TypeError('Invalid supermajority parameters');
	}

	return Math.ceil((total * numerator) / denominator);
}

function assertRoot(root) {
	requireNonEmptyString(root.constitutionId, 'root.constitutionId');
	requireNonEmptyString(root.digest, 'root.digest');

	if (root.status !== undefined && root.status !== 'in-force') {
		throw new Error('The source constitutional root is not in force');
	}
}

function assertTransitionPlan(plan) {
	requireNonEmptyString(plan.safeState, 'transitionPlan.safeState');

	if (!Array.isArray(plan.steps) || plan.steps.length === 0) {
		throw new TypeError('transitionPlan.steps must be a non-empty array');
	}

	requireUniqueStrings(
		plan.steps.map((step) => step.id),
		'transitionPlan.steps[].id',
	);
}

export function createAmendmentProposal({
	id,
	exactText,
	proposedAt,
	sourceRoot,
	ratificationMode,
	changes,
	transitionPlan,
}) {
	requireNonEmptyString(id, 'id');
	requireNonEmptyString(exactText, 'exactText');
	requireNonEmptyString(proposedAt, 'proposedAt');
	assertRoot(sourceRoot);
	assertTransitionPlan(transitionPlan);

	if (!RATIFICATION_MODES.includes(ratificationMode)) {
		throw new TypeError('Unsupported ratification mode');
	}

	if (!Array.isArray(changes)) {
		throw new TypeError('changes must be an array');
	}

	const content = {
		id,
		exactText,
		proposedAt,
		sourceRoot: {
			constitutionId: sourceRoot.constitutionId,
			digest: sourceRoot.digest,
			authorityGrants: [...(sourceRoot.authorityGrants ?? [])],
			establishedBy: sourceRoot.establishedBy ?? null,
		},
		ratificationMode,
		changes,
		transitionPlan,
	};

	return deepFreeze({
		...content,
		digest: digest(content),
		status: 'draft-proposal',
		trace: [ARTICLE_V.rules.proposal, ARTICLE_V.rules.transition],
	});
}

function evaluateHouseVote(vote, chamber) {
	if (
		vote?.quorumMet !== true ||
		!Number.isInteger(vote.present) ||
		!Number.isInteger(vote.yes) ||
		vote.present < 1 ||
		vote.yes < 0 ||
		vote.yes > vote.present
	) {
		return deepFreeze({
			chamber,
			accepted: false,
			reason: 'invalid-vote-or-no-quorum',
		});
	}

	const threshold = requiredVotes(vote.present, 2, 3);

	return deepFreeze({
		chamber,
		accepted: vote.yes >= threshold,
		yes: vote.yes,
		present: vote.present,
		threshold,
		reason: vote.yes >= threshold ? 'two-thirds-of-members-present' : 'two-thirds-not-reached',
	});
}

function countConventionApplications(applications, federation) {
	const knownStates = new Set(federation.states);
	const accepted = new Set();

	for (const application of applications) {
		if (
			knownStates.has(application.state) &&
			application.source === 'state-legislature' &&
			application.authenticated === true &&
			application.requests === 'article-v-convention'
		) {
			accepted.add(application.state);
		}
	}

	return accepted;
}

export function authorizeProposal({ proposal, route, federation }) {
	requireUniqueStrings(federation.states, 'federation.states');

	if (route.kind === 'congress') {
		const house = evaluateHouseVote(route.house, 'House');
		const senate = evaluateHouseVote(route.senate, 'Senate');
		const ratificationModeVerified =
			route.ratificationModeSelectedByCongress === proposal.ratificationMode;
		const authorized = house.accepted && senate.accepted && ratificationModeVerified;

		return deepFreeze({
			proposalDigest: proposal.digest,
			route: 'congress',
			authorized,
			house,
			senate,
			ratificationModeVerified,
			presidentialApproval: 'not-part-of-article-v-proposal',
			reason: !ratificationModeVerified
				? 'ratification-mode-not-selected-by-congress'
				: authorized
					? 'two-thirds-in-both-houses'
					: 'congressional-threshold-not-reached',
			trace: [ARTICLE_V.rules.proposal],
		});
	}

	if (route.kind === 'convention') {
		const applications = countConventionApplications(route.applications ?? [], federation);
		const threshold = requiredVotes(federation.states.length, 2, 3);
		const applicationThresholdMet = applications.size >= threshold;
		const conventionProposalVerified =
			route.convention?.calledByCongress === true &&
			route.convention?.proposalCertified === true &&
			route.convention?.proposalDigest === proposal.digest;
		const ratificationModeVerified =
			route.ratificationModeSelectedByCongress === proposal.ratificationMode;
		const authorized =
			applicationThresholdMet && conventionProposalVerified && ratificationModeVerified;

		return deepFreeze({
			proposalDigest: proposal.digest,
			route: 'convention',
			authorized,
			applicationsBy: [...applications],
			applicationThreshold: threshold,
			conventionProposalVerified,
			ratificationModeVerified,
			reason: !ratificationModeVerified
				? 'ratification-mode-not-selected-by-congress'
				: authorized
					? 'two-thirds-applications-and-certified-convention-proposal'
					: 'convention-route-incomplete',
			unresolvedProtocol: 'article-v-does-not-specify-the-convention-internal-procedure',
			trace: [ARTICLE_V.rules.proposal],
		});
	}

	throw new TypeError('Unsupported proposal route');
}

function amendmentYear(proposal) {
	const year = Number.parseInt(proposal.proposedAt.slice(0, 4), 10);

	if (!Number.isInteger(year)) {
		throw new TypeError('proposedAt must begin with a four-digit year');
	}

	return year;
}

function checkEntrenchment({ proposal, ratifiedBy, individualConsents, knownStates }) {
	const temporaryTargets = new Set(['I.9.1', 'I.9.4']);
	const affectsTemporaryTarget = proposal.changes.some(
		(change) => temporaryTargets.has(change.target) && change.effect === 'affect',
	);

	if (amendmentYear(proposal) < 1808 && affectsTemporaryTarget) {
		return deepFreeze({
			accepted: false,
			reason: 'pre-1808-protected-subject',
			missingConsentFrom: [],
			trace: [ARTICLE_V.rules.entrenchment1808],
		});
	}

	const speciallyConsentingStates = new Set(ratifiedBy);

	for (const consent of individualConsents) {
		if (
			knownStates.has(consent.state) &&
			consent.authenticated === true &&
			consent.proposalDigest === proposal.digest &&
			consent.consent === true
		) {
			speciallyConsentingStates.add(consent.state);
		}
	}

	const affectedStates = new Set(
		proposal.changes
			.filter((change) => change.target === 'senate.equal-suffrage' && change.effect === 'deprive')
			.flatMap((change) => change.affectedStates ?? []),
	);
	const missingConsentFrom = [...affectedStates].filter(
		(state) => !speciallyConsentingStates.has(state),
	);

	return deepFreeze({
		accepted: missingConsentFrom.length === 0,
		reason:
			missingConsentFrom.length === 0
				? 'entrenchment-check-passed'
				: 'equal-suffrage-consent-missing',
		missingConsentFrom,
		trace: [ARTICLE_V.rules.equalSuffrage],
	});
}

export function evaluateRatification({
	proposal,
	authorization,
	federation,
	actions,
	individualConsents = [],
}) {
	requireUniqueStrings(federation.states, 'federation.states');

	if (authorization.authorized !== true || authorization.proposalDigest !== proposal.digest) {
		throw new Error('The proposal has not been validly authorized');
	}

	const knownStates = new Set(federation.states);
	const ratified = new Map();
	const rejected = new Set();
	const disputed = new Set();
	const ignored = [];

	const orderedActions = [...actions].sort((left, right) =>
		String(left.receivedAt).localeCompare(String(right.receivedAt)),
	);

	for (const action of orderedActions) {
		if (
			!knownStates.has(action.state) ||
			action.authenticated !== true ||
			action.proposalDigest !== proposal.digest ||
			action.mode !== proposal.ratificationMode
		) {
			ignored.push({ state: action.state, reason: 'ineligible-action' });
			continue;
		}

		if (action.decision === 'rescind') {
			ratified.delete(action.state);
			disputed.add(action.state);
			continue;
		}

		if (disputed.has(action.state)) {
			ignored.push({
				state: action.state,
				reason: 'rescission-requires-review',
			});
			continue;
		}

		if (action.decision === 'ratify') {
			if (!ratified.has(action.state)) {
				ratified.set(action.state, action.receivedAt);
			}
			rejected.delete(action.state);
			continue;
		}

		if (action.decision === 'reject') {
			rejected.add(action.state);
			continue;
		}

		ignored.push({ state: action.state, reason: 'unsupported-decision' });
	}

	const threshold = requiredVotes(federation.states.length, 3, 4);
	const ratifiedBy = [...ratified.keys()];
	const thresholdMet = ratifiedBy.length >= threshold;
	const entrenchment = checkEntrenchment({
		proposal,
		ratifiedBy,
		individualConsents,
		knownStates,
	});
	const adopted = thresholdMet && entrenchment.accepted;
	const thresholdDates = [...ratified.values()].sort();

	return deepFreeze({
		proposalDigest: proposal.digest,
		status: adopted
			? 'ratified'
			: thresholdMet
				? 'blocked-by-entrenchment'
				: disputed.size > 0
					? 'requires-review'
					: 'proposed',
		constitutionalStatus: adopted ? 'part-of-constitution' : 'previous-revision-remains-in-force',
		ratifiedBy,
		rejectedBy: [...rejected],
		disputedStates: [...disputed],
		ignored,
		threshold,
		thresholdMet,
		ratifiedAt: adopted ? thresholdDates[threshold - 1] : null,
		entrenchment,
		attestationStatus: adopted ? 'pending-official-notice' : 'not-available',
		trace: [ARTICLE_V.rules.ratification, ...entrenchment.trace],
	});
}

export function attestAndIntegrate({ proposal, ratification, attestor, attestedAt }) {
	requireNonEmptyString(attestor, 'attestor');
	requireNonEmptyString(attestedAt, 'attestedAt');

	if (ratification.status !== 'ratified' || ratification.proposalDigest !== proposal.digest) {
		throw new Error('Only a ratified amendment can be attested');
	}

	const rootContent = {
		constitutionId: `${proposal.sourceRoot.constitutionId}+${proposal.id}`,
		parentDigest: proposal.sourceRoot.digest,
		amendmentDigest: proposal.digest,
		ratifiedAt: ratification.ratifiedAt,
		authorityGrants: proposal.sourceRoot.authorityGrants,
		establishedBy: 'article-v-ratification',
	};

	return deepFreeze({
		attestation: {
			attestor,
			attestedAt,
			status: 'official-notice-of-completed-ratification',
			createsValidity: false,
			ratifiedBy: ratification.ratifiedBy,
		},
		constitutionalRoot: {
			...rootContent,
			digest: digest(rootContent),
			status: 'in-force',
			lineage: [proposal.sourceRoot.digest, proposal.digest, digest(rootContent)],
		},
		trace: [ARTICLE_V.rules.ratification],
	});
}

export function executeTransition({ proposal, integration, stepResults }) {
	const expectedSteps = new Set(proposal.transitionPlan.steps.map((step) => step.id));
	const received = new Map(stepResults.map((result) => [result.id, result.status]));
	const failed = [...expectedSteps].filter((id) => received.get(id) !== 'passed');

	if (failed.length === 0) {
		return deepFreeze({
			normativeRoot: integration.constitutionalRoot,
			runtimeStatus: 'aligned',
			runtimeRevision: integration.constitutionalRoot.constitutionId,
			failedSteps: [],
			requiredAction: 'observe',
			trace: [ARTICLE_V.rules.transition],
		});
	}

	return deepFreeze({
		normativeRoot: integration.constitutionalRoot,
		runtimeStatus: 'safe-state',
		runtimeRevision: proposal.sourceRoot.constitutionId,
		safeState: proposal.transitionPlan.safeState,
		failedSteps: failed,
		requiredAction: 'restore-transition-or-adopt-another-amendment',
		silentConstitutionalRollback: false,
		trace: [ARTICLE_V.rules.transition],
	});
}

export function upgradeKernel({
	proposal,
	route,
	federation,
	ratificationActions,
	individualConsents,
	attestation,
	stepResults,
}) {
	const authorization = authorizeProposal({ proposal, route, federation });

	if (!authorization.authorized) {
		return deepFreeze({
			phase: 'proposal-rejected',
			authorization,
			normativeRoot: proposal.sourceRoot,
		});
	}

	const ratification = evaluateRatification({
		proposal,
		authorization,
		federation,
		actions: ratificationActions,
		individualConsents,
	});

	if (ratification.status !== 'ratified') {
		return deepFreeze({
			phase: ratification.status,
			authorization,
			ratification,
			normativeRoot: proposal.sourceRoot,
		});
	}

	const integration = attestAndIntegrate({
		proposal,
		ratification,
		...attestation,
	});
	const transition = executeTransition({
		proposal,
		integration,
		stepResults,
	});

	return deepFreeze({
		phase: transition.runtimeStatus === 'aligned' ? 'upgrade-complete' : 'upgrade-in-recovery',
		authorization,
		ratification,
		integration,
		transition,
		normativeRoot: integration.constitutionalRoot,
	});
}

The module intentionally contains fields whose values come from external verification. authenticated means that a separate process has verified the document’s form and signature. proposalCertified reports an authenticated convention result. changes contains a completed classification of the provisions affected. The program applies the consequences of those assertions and preserves their provenance; it does not replace legal interpretation.

canonicalJson() sorts keys before calculating SHA-256, so the same object receives a stable digest when its content is identical. This mechanism is suitable for a prototype and for tracing. A production system would need a canonical serialization specification, real signatures, trusted time, an authority registry, and a protected log.

WARDEN: twenty-three ways to survive an update

WARDEN tests the third build at four levels: proposal, ratification, entrenched provisions, and transition. Every test declares the source of its invariant. Direct rules of Article V remain separate from the National Archives’ administrative practice and from the engineering norms of Code Constitution.

flowchart TB
    A["Text of Article V"] --> D["Proposal and ratification invariants"]
    B["Official attestation procedure"] --> E["Publication invariants"]
    C["Code Constitution"] --> F["Transition invariants"]
    D --> G["WARDEN: 23 scenarios"]
    E --> G
    F --> G
    G --> H{"Are root, text, and state aligned?"}
    H -- "Yes" --> I["Build admitted to Article IV"]
    H -- "No" --> J["Review code, data, or interpretation"]

The complete suite runs with node --test and contains twenty-three scenarios:

The compact excerpt below shows the most important negative cases: an insufficient threshold, a mismatched revision, special consent, and migration failure.

wardenTest(
	'thirty-seven states leave the previous revision in force',
	[ARTICLE_V.rules.ratification],
	() => {
		const proposal = makeProposal();
		const result = ratify(proposal, 37);

		assert.equal(result.status, 'proposed');
		assert.equal(result.threshold, 38);
		assert.equal(result.constitutionalStatus, 'previous-revision-remains-in-force');
	},
);

wardenTest(
	'assent to altered text does not ratify the original proposal',
	[ARTICLE_V.rules.ratification],
	() => {
		const proposal = makeProposal();
		const actions = ratificationActions(proposal, 38);
		actions[37] = { ...actions[37], proposalDigest: 'sha256:other-text' };

		const result = ratify(proposal, 0, { actions });

		assert.equal(result.ratifiedBy.length, 37);
		assert.equal(result.status, 'proposed');
	},
);

wardenTest(
	'a state retains equal representation without its own consent',
	[ARTICLE_V.rules.equalSuffrage],
	() => {
		const proposal = makeProposal({
			id: 'amendment:senate-suffrage',
			changes: [
				{
					target: 'senate.equal-suffrage',
					effect: 'deprive',
					affectedStates: [states[49]],
				},
			],
		});

		const result = ratify(proposal, 38);

		assert.equal(result.status, 'blocked-by-entrenchment');
		assert.deepEqual(result.entrenchment.missingConsentFrom, [states[49]]);
	},
);

wardenTest(
	'migration failure activates a safe state without repealing the amendment',
	[ARTICLE_V.rules.transition],
	() => {
		const proposal = makeProposal();
		const ratification = ratify(proposal, 38);
		const integration = attestAndIntegrate({
			proposal,
			ratification,
			attestor: 'Archivist of the United States',
			attestedAt: '2026-08-03',
		});
		const transition = executeTransition({
			proposal,
			integration,
			stepResults: [
				{ id: 'publish-canonical-corpus', status: 'passed' },
				{ id: 'update-derived-legislation', status: 'failed' },
			],
		});

		assert.equal(transition.runtimeStatus, 'safe-state');
		assert.equal(transition.normativeRoot.status, 'in-force');
		assert.equal(transition.silentConstitutionalRollback, false);
	},
);

All twenty-three scenarios pass. The technical-rollback test proved the most revealing. The previous runtime can indeed return temporarily in a constrained mode, but normativeRoot remains new. WARDEN thereby separates restoration of operability from repeal of a norm and prevents an emergency script from accidentally acquiring constituent authority.

What Article V gives software architecture

The third publication leaves seven practical conclusions.

Self-modification receives a distinct authority. The architectural layer changes through a process different from ordinary configuration or a derivative rule. Technical access to a repository or infrastructure does not replace a constituent mandate.

A reserve route protects the system from a captured initiator. A body with an interest in preserving its own powers loses its monopoly over considering a change. The alternative entrance retains the same demands for precision, evidence, and ratification.

Participants confirm one artifact. The exact text, digest, source root, and selected mode form the object of consent. An editorial revision with a new meaning creates a new proposal revision.

Adoption, attestation, and migration are different events. Normative force, official publication, and material execution receive separate states, dates, and responsible actors.

A supermajority encounters individual limits. An entrenched provision may require consent from a specifically affected participant. A distributed system thereby distinguishes a collective decision from the guaranteed position of a node.

A transition failure initiates recovery. A safe state, compatibility, and observation support the new norm while repairs continue. Technical reversibility does not create normative repeal.

Every revision preserves provenance. The new root contains the parent digest, amendment digest, ratification moment, and its own digest. History becomes a verifiable line, while the former identifier remains available for audit and compatibility.

These properties apply to projects with multiple owners, compatibility protocols, governance of high-risk data schemas, supply chains, and systems where an architectural change affects autonomous teams. Article V is especially good at revealing the price of the phrase “we’ll just update it”: simplicity usually lives in the presentation, while distributed consequences have already begun drafting a separate budget.

Where the third experiment ends

Article V combines high procedural determinacy with large omissions. A machine can confidently calculate thresholds, eliminate duplicates, compare digests, verify the selected mode, and preserve the version line. The meaning of a particular amendment, the validity of a ratification instrument, and classification of a deprivation of equal representation require a legal decision.

The convention route remains especially incomplete. The original text obliges Congress to call a convention after the required number of applications, but it does not disclose the convention’s internal architecture. A complete implementation would need rules for aggregating applications, subject-matter compatibility, delegation, voting, certification, and dispute resolution. The current module preserves the outcome as an externally verified fact and marks the gap.

Ratification deadlines, prior rejection, and rescission of consent also belong to developed doctrine and political practice. The example of the Twenty-seventh Amendment forbids inventing a universal timeout for developer convenience. The prototype records a contested event and waits for a competent decision.

The prototype’s technical protection remains laboratory-scale. Object.freeze() prevents ordinary mutation of an object within a process; it does not protect storage. SHA-256 confirms equality of a representation; it does not authenticate its author. A date string does not create trusted time. A production version would require signed events, an append-only log, a formal schema, a reproducible corpus build, and separated attestation.

WARDEN confirms that the code conforms to the selected invariants. It does not confirm that those invariants exhaust the law of Article V. The stronger the program becomes, the more important this distinction is: a fast and faultless algorithm can execute a misclassified amendment with exemplary efficiency.

The third result substantially strengthens the overall hypothesis. Article V transfers into software architecture as a real protocol for versioning, multilateral consent, entrenched constraints, and safe transition. Completeness of execution continues to depend on human interpretation and institutional fact, while the software form can already store that dependence instead of concealing it.

The eagle survived the kernel update. Its new version acquired provenance, lineage, and a recovery plan—three qualities that state symbolism generally regards as unnecessary bureaucracy until the first production outage.

Conclusion

Article VII gave the Constitution its moment of establishment. Article VI created a root of trust and taught derivative decisions to prove their provenance. Article V gives the operating system a way to change the root itself through two proposal routes, one ratification mode selected in advance, the consent of three fourths of the states, and special limits for entrenched provisions.

In code, this order becomes an exact artifact, a stable digest, two authorization processes, a ratification log, a new root, and a separate runtime transition. Attestation reports the force already achieved, migration implements it materially, and failure activates a safe state without a concealed repeal of the amendment.

The software interpretation survives its third test and becomes more substantive. It now describes an architecture able to establish itself, trust, and alter its own foundation over time. The next publication turns to Article IV. The updated kernel will have to operate among autonomous states, recognize their acts, support movement between jurisdictions, and admit new nodes to the federation.

Continue the research with AI

The site renders this section from the independent question set constitution-runtime.article-v.upgrade-kernel, stored in the companion catalog constitution-runtime-03-article-v-questions.yaml. Every prompt independently identifies its Article V issue, software object, and interpretive boundary, so it can be opened outside this article without losing the subject.

The recommended route is root in force → proposal → exact artifact → ratification → entrenched provisions → attestation → migration → WARDEN → limits. The bilingual catalog contains the AI answer contract, 53 standalone prompts, branch triggers, code references, visual references, and return navigation.

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; official amendment procedure; overview of Article V; congressional proposal of amendments; convention route; role of the President; ratification; ratification mode; ratification deadlines; rejection and rescission; entrenched provisions; 1 U.S.C. § 106b; National Archives materials on the Twenty-first and Twenty-seventh Amendments
Related publications: “Connect America: How Article VII Bootstraps a Republic”; “What America Trusts: How Article VI Assembles the Supreme Order”
Next publication: Article IV — in development
Publication revision: 0.2 · 13 August 2026