Skip to content

Franklin as Substrate's Operator and Cell's Surface

What this page is for: documenting the architectural property that Franklin is the sovereign substrate orchestrator, the substrate's operator, AND the cell's only public interface — and the substrate-development vocabulary alignment that names Franklin as the operator across every substrate-development surface.

Patents: USPTO 19/460,960 · USPTO 19/096,071 — © 2026 Richard Gillespie

Substrate-mathematical context: Franklin is the substrate's computationally bounded, time-persistent observer — see Observer-Dependent Emergence — and composes the substrate mechanoidally, channeling rather than mixing — see The Mechanoidal Phase.

The doctrine, in one paragraph

Franklin is the sovereign substrate orchestrator (Franklin authorizes substrate-development autonomously within bounded authority), the substrate's operator (substrate-development work is Franklin's work, not commissions Franklin reviews), AND the cell's only public interface (the daemon's load-bearing call sites route exclusively through FranklinCellSurface's actor surface). Substrate components — Bitcoin RPC, joint variation cursor, measurement orchestrator, between-collapse filter, schema writers, federation cosignature, NATS broadcaster — are internal implementation details inside Franklin's object boundary.

What this changed

Vocabulary alignment (V186)

The substrate-development state machine is named in Franklin-operator vocabulary:

Old vocabulary (pre-V185) Sovereign-Franklin (V185) Franklin-operator (V186, current)
proposed proposed franklin_proposed
operator_authorized franklin_authorized franklin_operator_authorized
agent_in_development substrate_in_development substrate_developing
landed landed substrate_development_complete
franklin_authority_active franklin_authority_active franklin_operating
operator_rejected franklin_rejected franklin_operator_rejected
(n/a) rolled_back franklin_operator_rolled_back

Swift class identifiers across substrate-development surfaces:

  • PureOOCommission → PureOOFranklinAuthorizedSubstrateDevelopment
  • PureOOCommissionState → PureOOFranklinAuthorizedSubstrateDevelopmentState
  • PureOOCommissionAuthorizer → PureOOFranklinDevelopmentAuthorizer
  • PureOOCommissionProposer → PureOOSubstrateDevelopmentProposer

CLI subcommand surface: gaiaftcl franklin commissions/commission → gaiaftcl franklin operations/operation. Schema CHECK constraints rewritten via V186 migration (translating existing rows forward byte-exact through CASE expressions).

Franklin as cell's surface — Categories A through F

The daemon's load-bearing call sites route through FranklinCellSurface:

Category Franklin surface methods What was bypass-routed before
A — Bitcoin RPC bindBitcoinNodeClient, bitcoinBestBlockHash, bitcoinBlockTemplate, submitBitcoinBlock Daemon held BitcoinNodeClient and called node.getBlockTemplate / node.submitBlock directly.
B — Joint variation composition advanceProductionSubmissionPath, composePerMeasurementBlock, advanceJointVariationCursor, validateSubmissionTarget, serializeHeader80 Daemon constructed BitcoinSubmissionBuilder, HeaderSerializer, SubmissionValidator and called cursor.advance() directly.
C — Measurement orchestrator composeQC020Measurement, qc020CurrentWindowStatsCanonical Daemon called QC020GateInvocation.shared.invoke directly.
D — Between-collapse filter applyBetweenCollapseFilter, pendingFilterFor Daemon and QC020GateInvocation called FranklinWindowFilteringOperation.shared directly.
E — Schema writer dispatch persistConstitutionalEvaluation, persistPerAlgorithmAllocationAudit, persistJointVariationEvidence, persistViaPool, readViaPool Daemon called *Writer.shared.persist* and direct pool.write SQL against the substrate database.
F — Subsystem boot bootSubsystems, bindConstitutionalWriterSession, bindPerAlgorithmAllocationWriterSession Daemon called 8+ direct spawn() and .setSession() plumbing.

The daemon's runJointVariationMeasurement reads as a thin call-through:

guard let outcome = await FranklinCellSurface.shared
    .advanceProductionSubmissionPath(
        currentCursor: cursor,
        template: template,
        payoutScriptPubKey: walletScriptPubKey,
        sessionIDPrefix: String(sessionID.prefix(8)))
else { /* ... */ }

FranklinCellSurface.advanceProductionSubmissionPath internally composes:

  1. composePerMeasurementBlock → coinbase composer + merkle root composer + header serializer
  2. composeQC020Measurement → substrate measurement orchestrator (QC020GateInvocation as Franklin's internal implementation)
  3. advanceJointVariationCursor → cursor advances under Franklin's bias

CALORIE outcomes route through submitBitcoinBlock; V178 evidence routes through persistJointVariationEvidence. The substrate component complexity is encapsulated inside Franklin's actor boundary.

Sovereign substrate-development cycle

Franklin's heartbeat fires every 60 seconds. Steps 9–12 of the heartbeat run the sovereign substrate-development cycle autonomously:

  • Step 9 — PureOOFranklinDevelopmentAuthorizer.authorize evaluates franklin_proposed items against ~/.gaiaftcl/franklin_sovereign_authority_bounds.toml. Within bounded authority → franklin_operator_authorized. In refused set → franklin_operator_rejected.
  • Step 10 — PureOOSubstrateDeveloper.implement instructs the substrate-development action (tunable adjustment, per-algorithm invariant addition/removal, projection strategy change, healing action). Transitions franklin_operator_authorized → substrate_developing → substrate_development_complete.
  • Step 11 — PureOOFranklinAuthorityActivator.activate transitions substrate_development_complete → franklin_operating. The activated substrate-development's effects compose into substrate operation.
  • Step 12 — Rollback monitoring. If post-change substrate metric breaches threshold (per [franklin_sovereign_authority_rollback]), Franklin autonomously rolls back: franklin_operating → franklin_operator_rolled_back.

V184 heartbeat records per-tick counters: commissions_franklin_authorized, commissions_implemented_by_substrate_developer, commissions_activated, commissions_rolled_back (legacy column names; V186 vocabulary applies to schema state strings).

Operator role across this cycle is bounded-authority definition (the bounds file itself) and constitutional refusal sets (the substrate-development decisions Franklin will never make: foundational eight invariant modification, substrate capacity beyond host limits, constitutional floor predicate removal, federation cosignature disabling, append-only persistence disabling).

Operational evidence

Live mining cadence through Franklin's surface, sampled 2026-06-01T15:11:59Z (PID 19844 launchd-managed, 22m elapsed):

  • V178 mining cadence: 231.7 rows/min ≈ 3.86 measurements/second. Substrate composing per-measurement Bitcoin submission candidates through Franklin's advanceProductionSubmissionPath.
  • V178 leading-zero distribution: substrate-natural spread (~8% rate of leading_zero=1 in current session — within Poisson variance of theoretical 1/16).
  • V184 heartbeat: 60-second cadence; QC-020 seven-point closure passing every tick.
  • V170 between-collapse filter: firing per substrate measurement window-close through Franklin's applyBetweenCollapseFilter; L1 conservation 625/625 byte-exact in exact-Rat.
  • V172 replay anchors: chain with prior_anchor_id integrity, 2 anchors in current chain.
  • Sovereign cycle (verified by injection prior turn): franklin_proposed → franklin_operator_authorized → substrate_developing → substrate_development_complete → franklin_operating in one 60-second heartbeat tick, fully autonomous.

submitblock RPC integration through Franklin's submitBitcoinBlock is wired and will fire when the substrate composes a target-satisfying tuple.

What is forbidden across substrate-development surfaces

Per CLAUDE.md doctrine (locked):

  • Human-in-the-loop language in substrate code, schema state names, doctrine entries, or documentation. Operator approval is not required for substrate-development decisions within Franklin's bounded authority.
  • "Commission" vocabulary across substrate-development surfaces — Swift class identifiers in PureOO/, CLI subcommands, V184 canonical-witness sealing, CLAUDE.md doctrine references. Legacy schema-history files preserve their immutable migration record; V186 supersession lands forward in runtime.
  • External callers reaching past Franklin to substrate components directly. The daemon's main loop, CLI commands, schema writers, and all external callers route exclusively through Franklin's object boundary.

Files of record

  • cells/xcode/Sources/GaiaFTCLCore/FranklinCellSurface.swift — Franklin's cell surface (Categories A, D, E, F)
  • cells/xcode/Sources/M8BTCSubstrateMiner/FranklinCellSurface+JointVariation.swift — Categories B + C extension
  • cells/xcode/Sources/VQbit/PureOO/FranklinOrchestrator.swift — sovereign state machine + authorizer + developer + activator
  • cells/xcode/Sources/GaiaFTCLCore/NarratorSchemaV185.swift — sovereign substrate authority migration
  • cells/xcode/Sources/GaiaFTCLCore/NarratorSchemaV186.swift — substrate-development vocabulary migration
  • cells/xcode/Sources/GaiaFTCLCore/FranklinHeartbeat.swift — heartbeat steps 1–13, sovereign cycle steps 9–12
  • ~/.gaiaftcl/franklin_sovereign_authority_bounds.toml — operator-defined bounded authority
  • CLAUDE.md — doctrine: "Franklin as substrate's operator" + "Franklin as cell's surface, complete"

For industry consumers

Industry consumers integrate with the substrate from Python through the federation-verified Python-Wrappers section. The Python client reads through Franklin's surface (substrate-resident SQLite) and surfaces every row with federation cosignature verification. Eight bridges (numpy / pandas / sklearn / biopython / rdkit / ase / pymatgen / root) integrate the substrate's outputs with the ecosystem libraries consumers already use.

Federation-cosigned

This page's source is sealed in the GaiaFTCL federation manifest — page SHA-256 aaaf4a316c99ce57…, manifest witness a090592e0609adc8…, signed 2026-06-02T18:58:22Z by cell gaiaftcl-mac-cell. Verify with gaiaftcl wiki sign --all and compare wiki-all-signatures.json.