ENGINE 33

SFS-E33-GDS · ENTITY COMPLIANCE · REV 2026-07-24 · PRODUCTION

PRODUCTION = runnable end-to-end, CI-backed, full test suite passing. All data fictional and seeded.

Entity Good-Standing

Is each entity in good standing in every state it belongs to, and does that recompute?

A closely-held real-estate family keeps its entities alive one (entity, state) registration at a time, and it has to prove, state by state, that each one clears every statutory gate at once -- the annual or biennial report filed on-or-before its due date and its fee met, the flat franchise tax paid in full and on time, the Secretary-of-State status ACTIVE, the registered agent of record the one under contract, and any required business licence current -- and then that every flag and count stacked on top of those records was recomputed, not typed. This engine reads the six artifacts the standing record carries -- the entity register, the jurisdiction matrix, the standing record register, the standing summary, the renewal watchlist and the compliance report -- and runs twenty-six deterministic controls over them across eleven families. Is the file complete and are the review date and filing year legible, is the entity register sound and every entity typed and status-valid, does every state an active entity belongs to have a matrix row and a record, is every record well-formed and attributable to a state the entity joined, does each report due date re-derive from the statute and was it filed on time with its fee met, is the franchise tax the flat statutory amount on its re-derived due date and paid on time, is the agent of record the contracted agent with fee paid, does an entity the register calls Active read ACTIVE at the Secretary of State, is any required business licence current, is every dissolved entity cancelled in every state it belonged to, and do each good-standing flag, the family counts and the renewal watchlist recompute from the state records beneath them. It re-derives every statutory due date rather than trusting it, compares every fee and franchise tax with exact >=, treats each timeliness gate as <= so a filing dated exactly on the due date is still on time, and never writes to a source artifact.

A good-standing register looks like the safest list in the binder: one line per entity, each marked Active, each state accounted for. That is exactly why it drifts. None of the ways it goes wrong look wrong in a column of one-line entries. A report or a franchise tax slips a day past its statutory due date and the entity drifts toward administrative suspension while the register still shows it Active -- just late. The franchise tax is paid a dollar under the flat amount, or the agent named on the state's record is not the one under contract, so service of process lands where nobody is watching -- and the paper looks complete. And the rollup -- the good-standing flag, the family count, the renewal watchlist -- is stated on a determination nobody recomputed from the state records beneath it. The engine re-derives every statutory due date from the filing year and the jurisdiction's own statute, holds every fee and franchise tax to the flat amount with exact >=, rebuilds each good-standing flag from the matrix and the records through one shared kernel, ships a planted-defect file for every registered control, and states its benchmark as a command rather than a claim. A lapsed filing, a short tax or a suspended status is invisible until the state serves a notice on an entity the register still calls Active.

Run it Book a consultation

Architecture

functional block stack · static overview

Select a layer

Eleven control families run in registry order over each standing file. The first proves the others had something to read and that the review date and filing year are legible, because a control that passes on absent evidence reports assurance it never performed.

Key specifications

at a glance

10,385¹

Tests

the collected checks that pin this engine's behavior

26²

Controls

independent rules run over every standing file

11³

Families

groups of controls, each answering one question

28⁴

Standing files

one clean baseline plus twenty-seven planted-defect files

6⁵

Artifacts read

entity register, jurisdiction matrix, standing record register, standing summary, renewal watchlist, compliance report

0⁶

Tolerance

a fee or tax a cent short of the statute is a break, not a rounding band

What it does for you

plain terms

A closely-held real-estate family forms one entity per project and qualifies it into each state it operates in, and it has to prove, entity by entity and state by state, that the paper on file actually keeps that entity alive: the annual or biennial report filed on-or-before its statutory due date and its fee met, the flat franchise tax paid in full and on time, the Secretary-of-State status ACTIVE, the registered agent of record the one under contract, and any required business licence current -- and that a wound-down entity has been cancelled in every state it ever touched. Three failures hide inside that, none of which look wrong in a register of one-line entries. A filing slips past its statutory due date, so the entity drifts toward administrative suspension while the internal register still shows it Active -- just late, and a suspended entity cannot sue, close a sale or borrow. The obligation is short or misdated -- a franchise tax a dollar under the flat statutory amount, a stated due date the statute does not re-derive, or an agent on the state's record who is not the agent under contract -- so the paper looks complete and the standing is not there. And the rollup calls an entity in good standing, or counts a family as clean, on a determination nobody recomputed from the state records underneath it. None of these are judgment calls. They are equalities and comparisons -- a filing date against a re-derived due date with <=, a franchise tax against the flat statutory amount with >=, a stated flag against its re-derivation -- which a deterministic control settles better than a register inherited by whoever tracks compliance this year.

The seeded demo runs every control over every standing file⁷. The CLI generates twenty-eight fictional standing files -- one clean baseline and one carrying each of the twenty-seven planted defects -- then runs all twenty-six controls over each. The clean file returns PASS with no flags; every defect file returns REVIEW or FAIL and names the control it tripped along with the reason that control exists.

The paper controls and the protection controls are independent⁸. The good-standing determination is the conjunction of the substantive gates only -- report and franchise filed on time and in full, SOS ACTIVE, agent current, licence current -- each checked at its boundary with <= or >=. The data-integrity controls that guard the paper sit outside that conjunction, so one defect file misdates a report due date without touching the filing date: fil_due_date_recomputes fails while roll_standing_recomputes still holds, proving a paper break is reported without silently moving the determination.

The determination is recomputed, not read back⁹. One defect file flips an entity's stated good-standing flag to false while its records still satisfy every obligation, and moves the family count with it so the two stay internally consistent. roll_standing_recomputes rebuilds the flag from the jurisdiction matrix and the state records through the shared kernel and fails, proving the standing summary is recomputed from the evidence beneath it rather than trusted as stated.

Functional block diagram

engineering · each block links to its source

Plain terms

Seeded Standing Files. fictional standing files enter the control registry
Structural Precondition. is the standing file complete and the review date and filing year legible
Entity Register. is the entity register sound and every entity typed and placed
Jurisdiction Obligations. does every required jurisdiction have a matrix row and a record
Standing Record Register. is every record well-formed and attributable
Annual/Biennial Report. does the report re-derive, file on time, meet its fee, and what renews
Franchise Tax. is the franchise tax the statutory amount, dated and paid on time
Registered Agent. is the agent of record the contracted agent, with fee paid
SOS Status Tie-Out. does an entity the register calls Active read ACTIVE at the SOS
Business License. is any required business license current
Dissolution Completeness. is every dissolved entity cancelled everywhere it belonged
Rollup Recompute. does the rollup recompute from the records it summarises
Register, Matrix & Records. the artifacts and dated statute every rule resolves against
Verdict and Findings. every finding, with the reason it exists, ends at a person

Engineering

Seeded Standing Files. generate_corpus writes one clean baseline plus one planted-defect file for every registered control, twenty-eight files in total. Only the entities, the jurisdiction matrix and the state records are stated -- and even each record's statutory due dates are computed from the matrix, so they cannot drift from the statute they claim to follow. Every rollup the engine later checks -- each entity's good-standing determination, the renewal watchlist and the family in-good-standing / not counts -- is re-derived through the same good-standing kernel the engine recomputes with, so the relationships the engine tests are the relationships that produced the data.
Structural Precondition. One control. FAILs a file missing any of the six artifact types or carrying a duplicate, an unreadable as_of review date, or a non-integer filing year, so no downstream rule holds vacuously on absent evidence.
Entity Register. Four controls: unique entity ids, a known entity type and register status on each, and a declared, known formation/qualified jurisdiction set.
Jurisdiction Obligations. Two controls: every state an active entity belongs to has a jurisdiction-matrix row for its type and a standing record on file, so no obligation is skipped for want of a statute or a record.
Standing Record Register. Four controls: the required descriptive fields present, a unique SOS file number, an entity that exists in the register, and a state the entity actually joined.
Annual/Biennial Report. Four controls: the stated report due date re-derives from the statute, the report was filed on-or-before it, the filing fee meets the statutory fee at exact >=, and a next report due inside the lead-time window is flagged.
Franchise Tax. Three controls: the franchise tax paid meets the flat statutory amount at exact >=, its due date re-derives from the statute, and it was paid on-or-before that date.
Registered Agent. Two controls, run where the jurisdiction requires a registered agent: the agent of record on the state's record equals the contracted agent, and that agent's annual fee is paid.
SOS Status Tie-Out. One control: every active entity's state record reads Secretary-of-State status ACTIVE, so the internal register and the state record reconcile.
Business License. One control, run where the jurisdiction requires a city business license: the licence reads current and its renewal date is still ahead of the review date.
Dissolution Completeness. One control: every state a dissolved entity ever belonged to carries a filed certificate of cancellation, so no wound-down entity keeps a live registration accruing obligations.
Rollup Recompute. Three controls: every entity good-standing flag recomputes from the matrix and the records, the report's good / not-good counts tie the summary, and the renewal watchlist ties the record evidence.
Register, Matrix & Records. The entity register carries each entity's id, type, register status and formation/qualified states; the jurisdiction matrix carries the per (state, entity_type) report cadence, flat report fee and franchise tax, the statutory due month and day, and the agent and licence requirements; the standing record register carries each per (entity, state) record's SOS status, report and franchise dates and paid amounts, agent, licence and cancellation; and the standing summary, renewal watchlist and compliance report carry the derived flags and counts. Every filing, tax, agent, status, licence, dissolution and rollup control resolves against these through the shared good-standing kernel.
Verdict and Findings. Findings roll up per standing file: any FAIL is FAIL, FLAGs without FAILs are REVIEW, clean is PASS. The CLI exit code is the verdict, so a pipeline can gate on it. Reports carry no timestamps or absolute paths, which is what makes the committed report diffable.

Instruction set

every public command

Command	Operation	Output	Exit	Artifacts
`python run.py`	regenerate the seeded fictional corpus, run all twenty-six controls, write both reports	per-file verdicts and every actionable finding, then the overall verdict	2 for the bundled corpus, which carries a planted defect for every control by design	standing_report.json, standing_report.md, samples/
`python -m standing_engine samples`	analyze an existing folder of standing files without regenerating it	per-file verdicts and findings	0 PASS / 1 REVIEW / 2 FAIL / 3 usage	none unless --json or --md is passed
`python -m standing_engine samples --generate --quiet`	regenerate the corpus and print only the overall verdict	a single verdict line	0 PASS / 1 REVIEW / 2 FAIL / 3 usage	samples/
`python -m pytest standing_engine/tests -q`	run the full test suite for this engine	10385 passed	0 when every test passes	none

Benchmarks

measured demo results

Measure	Result
Engine tests¹⁰	10,385 tests collected live collection from the engine directory
Registered controls¹¹	26 controls counted from the registry, not from documentation
Planted defects¹²	27 defect files every registered control has at least one file that trips it
Control coverage¹³	100 percent of controls with a planted defect no control ships without a file demonstrating it firing

Control characteristics

engineering

Plain terms

The engine has no write path and therefore no autonomy to gate. It produces findings; a person decides whether an entity is certified in good standing and whether a lapsed filing, a short franchise tax or a mismatched agent is chased.

Engineering

Deterministic envelope. seeded fictional inputs, read-only operation, offline default mode.

Demo gate. FAIL on the bundled corpus, by design -- it carries a planted defect for every registered control

Severity	Verdict	Action
No findings above PASS	PASS	carry the mechanically clean standing file into the documented compliance sign-off
One or more FLAG, no FAIL	REVIEW	a human resolves each flag; a filing due inside the renewal lead-time window and a watchlist that does not tie the evidence both land here
One or more FAIL	FAIL	the entity is not certified in good standing until the failing control is cleared -- a lapsed filing, a short or late franchise tax, a suspended status, a mismatched agent, an incomplete dissolution, or a determination that does not recompute

Read-only: standing files are parsed and never written back, so the engine cannot introduce the break it reports.
Integer cents throughout, fees and taxes compared with exact >=; there is no tolerance band, and a cent short of the statutory amount is reported as a break.
A fee or tax that should be integer cents but is not produces an AMOUNT_INVALID finding contained to the one row it was read on, rather than being coerced into the number the engine is meant to audit.
One good-standing kernel: the controls and the generator share the predicate in standing_engine.standing, so a determination cannot disagree with the data that produced it.
Statutory due dates are re-derived from the filing year and the jurisdiction's statutory month and day, not trusted as stated, and each timeliness gate is on-or-before (<=) at the due date.
The good-standing determination is the conjunction of the substantive gates only; the paper-integrity controls can fail without moving it, so a misdated due date is reported without silently changing standing.
Deterministic and byte-stable: same inputs produce the same findings in the same order, with no timestamps or absolute paths in any output.
Absent evidence is never a passing control; a missing artifact fails completeness rather than letting the controls that read it pass unread.

Operating limits

what it refuses to do

The engine never files a report, pays a franchise tax or an agent fee, requests or files a certificate of cancellation, contacts a Secretary of State or a registered agent, or writes to a source artifact. It reads the standing file and stops.¹⁴
It reads the six artifacts the standing record emits. It does not connect to a Secretary-of-State system, a registered-agent provider, a franchise-tax authority or a general ledger.¹⁵
It proves a record clears the mechanical gates -- report filed on time and fee met, franchise tax paid in full and on time, SOS ACTIVE, agent and licence current -- not that the state's filing actually posted or that a certificate of cancellation is authentic. That confirmation is a filer's and a reviewer's.¹⁶
It re-derives each due date and holds each fee and franchise tax to the flat statutory amount the jurisdiction matrix carries; it does not decide whether that fee or that amount is the correct one for the year and jurisdiction.¹⁷
It takes the register, matrix and records at face value: it confirms they foot, re-derive and reconcile, not that an entity should have been formed or qualified in a given state. All shipped data is fictional and the compliance period is set in a fictional future.¹⁸

See it run

control architecture

Corporate obligation-matrix architecture for Entity Good-Standing: entity and document records pass through jurisdiction and policy controls to verified reporting evidence. — The Entity Good-Standing engine tile states the question that has to hold entity by entity and state by state: every active entity filed on time, paid the flat franchise tax in full, reads ACTIVE at the Secretary of State, holds its contracted agent and any required licence, and every dissolved entity is cancelled everywhere it belonged, with the standing summary, the family counts and the renewal watchlist all recomputed from the state records beneath them.

Integration

how to run it

Distribution: public repository, MIT license.

python run.py

python -m pytest standing_engine/tests -q

Source on GitHub Engine README All tests, by engine Run in Codespaces

Substantiation

1python -m pytest --collect-only -q -o addopts= (good-standing-automation/)
2len(standing_engine.engine.REGISTRY)
3distinct rule-id prefixes in standing_engine.engine.REGISTRY
4samples/*.json after python run.py
5len(standing_engine.model.DOC_TYPES)
6standing_engine/tests boundary tests on the cent and the due date
7python run.py (good-standing-automation/); standing_engine/tests planted-defect suite
8standing_engine/generate.py DEFECTS report_due_date_wrong; standing_engine/standing.py record_in_good_standing
9standing_engine/generate.py DEFECTS standing_flag_wrong -> roll_standing_recomputes
10python -m pytest --collect-only -q -o addopts= (good-standing-automation/)
11len(standing_engine.engine.REGISTRY)
12len(standing_engine.generate.DEFECTS)
13standing_engine/tests: every registered rule has a planted defect
14good-standing-automation/README.md and standing_engine read-only / determinism tests
15standing_engine/model.py DOC_TYPES
16standing_engine/engine.py fil_, tax_, sts_, agt_, lic_ and dis_ families
17standing_engine/engine.py fil_due_date_recomputes / tax_due_date_recomputes and the fil_ / tax_ amount families
18standing_engine/generate.py

Show us where the hours go.

One conversation: you describe the work that consumes your team's month; we tell you plainly what this engine can take over, what it can't, and what a scoped first phase would cost. Your people keep approval authority.

Book a free consultation