MathSphere Nexus official corporate seal MathSphere Nexus

The Hub — Approved Users and Their Projects

A prototype of the Wizard Central Pro AI Modes Toolkit · Went into implementation: November 13, 2026 · Tested the same day · Status: proof of shape — Layer 2 of the multi-user design, whose real build stands in the roadmap at Phase 6 (§6.7). The excerpts below are the prototype's actual code.


The idea

On a shared machine, the owner approves people onto the installation — and they become his responsibility, because it is his machine and he approved them. They work on the creative side, in projects. The hub layer adds four things to the floor. A local users registry: the owner approves a person with a username and a password, stored salted and hashed; sign-in returns a session, and wrong passwords and unapproved names are refused. The author field, bound to the sign-in: when a signed-in user creates a project, its author is their username — the floor's typed claim, filled by the sign-in itself. A password for every project, set by its creator: a project opens with its own password — for everyone, the owner included; there is no master key. And existence vs. contents: the owner may remove a user (their live sessions die in the same motion) and delete a project (double-asked, export first) — but a project's contents are never his to open, and a removed user's projects survive: projects never delete on their own.

How it works

Creation — the field binds itself

    def create_project(self, token, name, classification, project_password,
                       contents=""):
        """The author field, bound to the sign-in: author IS the username."""
        author = self._who(token)
        if name in self.projects:
            raise ValueError(f"project already exists: {name}")
        salt, digest = _pw_hash(project_password)
        self.projects[name] = {
            "name": name,
            "classification": classification,
            "author": author,
            "salt": salt,
            "hash": digest,
            "contents": contents,
        }
        self.chain.append(
            "project_created", project=name,
            classification=classification, author=author,
        )
        self._save()
        return self.projects[name]

Opening — no master key

    def open_project(self, token, name, project_password):
        """Contents open with the project's password — for everyone,
        the owner included. There is no master key."""
        self._who(token)
        proj = self.projects[name]
        if not _pw_matches(project_password, proj["salt"], proj["hash"]):
            raise PermissionError("a project opens with its own password")
        self.chain.append("project_opened", project=name, author=proj["author"])
        return {
            "name": proj["name"],
            "classification": proj["classification"],
            "author": proj["author"],
            "contents": proj["contents"],
        }

The load-bearing test of the whole prototype is one line of its run below: owner refused opening without the project password. The owner's power is over existence, never over contents.

Removal — the person goes, the work stays

    def remove_user(self, owner_token, username):
        """The owner's unilateral act: the user goes, and every live
        session of theirs dies in the same motion."""
        by = self._owner_who(owner_token)
        if username == self.owner:
            raise PermissionError("the owner cannot remove themselves")
        del self.users[username]
        self.sessions = {t: u for t, u in self.sessions.items() if u != username}
        self.chain.append("user_removed", user=username, by=by)
        self._save()

Deleting a project is the floor's rule unchanged: the owner's act only, the double-ask as a call contract, and the export — name, classification, author, contents — written to a file before the project is removed, and named on the receipt.

The evidence

Result on November 13, 2026: 18 checks, all passing — including the owner refused at a project's door, a removed user's session dying mid-flight while her project survives her, and a deliberate tamper of the receipt chain, caught by verification.

The Terminal Record

The dated terminal proof of the run above — the actual output, unedited — followed by its parse: how to use everything that was tested and proved.

$ date
Friday, November 13, 2026 — 17:45 PST
$ python3 test_hub_prototype.py
ok - owner approves a user; the user signs in
ok - wrong-password sign-in refused
ok - unapproved sign-in refused
ok - project author is the signed-in username
ok - project opens with its password
ok - wrong project password refused
ok - owner refused opening without the project password
ok - non-owner project delete refused
ok - project delete without double-ask refused
ok - project survives refused deletes
ok - removed user's session is dead
ok - removed user cannot sign in again
ok - project survives its author's removal
ok - export produced before delete
ok - export carries the author's work
ok - project deleted by owner act
ok - chain verifies
ok - tamper detected

all 18 checks passed

The parse — how each proved thing is used. To bring a person onto the machine, the owner approves them (username, password); they sign in and hold a session (owner approves a user; the user signs in) — a wrong password or a name never approved gets nothing (wrong-password sign-in refused, unapproved sign-in refused). To start work, a signed-in user creates a project with a name, a classification, and a project password; the author line fills itself from the sign-in (project author is the signed-in username). To open a project, anyone — creator, another user, the owner — presents the project's password; without it the door does not move (project opens with its password, wrong project password refused, owner refused opening without the project password). To end a person's time on the machine, the owner removes them: the registry entry goes, their live session dies in the same motion, they cannot sign in again — and their projects remain exactly where they were (removed user's session is dead, removed user cannot sign in again, project survives its author's removal). To remove a project, only the owner calls it, double-asked, and the export lands first (non-owner project delete refused, project delete without double-ask refused, export produced before delete, project deleted by owner act). The chain records all of it and catches later edits (chain verifies, tamper detected).

The house check

Receipts, hash-chained — approvals, sign-ins, creations, openings, removals, deletions; the chain verifies and catches tampering. Double-ask on destructive acts — enforced as the call contract: a project deletion that does not arrive double-asked is refused outright. Standard library only — password hashing is the standard library's salted PBKDF. Demo discipline — this page is the documentation half; the test file is the live half.

What this does not prove

Two honesty labels, stated plainly. Project contents are stored unencrypted in the prototype: what is proved is the password gate on opening — nobody, owner included, opens a project without its password — not encryption of the contents at rest; that belongs to the product build. And the password hash runs at a deliberately small iteration count so the tests run fast; a real build sets it properly. The prototype also contains no creative surfaces, no guide, and no gate — it proves the hub's registry, sign-in, authorship binding, sealed contents, and existence powers, in miniature.

← All prototypes


A command is what you type. The name is what the project is.

The owner’s run

On Saturday, November 14, 2026, the owner ran all four prototypes together on his own machine — one runner, four suites. This prototype’s verdict in that run:

all 18 checks passed

and the run’s summary closed: All four prototypes pass house.