ENGINE 25

SFS-E25-DUE · FILING COMPLIANCE · REV 2026-07-24 · PRODUCTION

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

Filing Obligation Calendar

Was every deadline met or validly deferred?

A group of entities carries a filing obligation in every jurisdiction it touches -- a federal return, a state return, a fixed-amount annual voucher -- and someone has to prove, entity by entity and obligation by obligation, that each one was filed or validly extended before its statutory deadline, that each fixed-amount payment went out in the exact amount the statute prints on the voucher, and that the status register ties to the filed evidence with nothing missing and nothing orphaned. A filing calendar is a grid of dates that was correct the day someone typed it, and it drifts in ways nobody watches until a notice arrives. This engine reads the seven artifacts the calendar carries -- the entity roster, the statutory due-dates table, the obligation register, the evidence index, the prior-year register, the status summary and the due-soon watchlist -- and runs twenty-two deterministic controls over them. Is the calendar file complete and the review date legible, does every obligation carry a readable year-end that maps to the statutory table and store an original and extended due date that re-derive from it, do the extension flag and the extended date agree, is anything past its applicable deadline unfiled or filed after it, is each fixed-amount payment the exact statutory constant, does every filed row tie to a voucher and every voucher back to a row, is the roster complete and every obligation attributable and uniquely identified, does the internal workflow schedule run in order, does an entity marked final in the prior year stay dissolved, and does the status roll-up recompute from the register it summarises rather than being read back as an assertion. It re-derives every due date from the form and the year-end with whole-month arithmetic, treats a deadline as met at the date and not a day past it, and never writes to a source artifact.

This is the calendar half of the tax story, the half that is not about what the return says or what the tax is: preparing the return and computing the tax are separate jobs, and this engine takes the finished calendar and proves only that every obligation was met or validly deferred on time. None of the failures here look wrong in a grid of dates. A due date is typed a day off, or an extension offset is keyed to the wrong form, and the whole register chases a deadline that is not the statutory one. An obligation is neither filed nor extended, its deadline slides past the review date, and it sits in the register looking like every other open row until it is a late-filing penalty. A row is marked filed with a receipt number but no voucher was ever archived, or a voucher sits in the archive with no row that claims it, and the count of done no longer means what it says. The annual LLC tax is a statutory constant, and a voucher cut a cent off it is wrong on its face. And the status summary calls an obligation filed, or a portfolio clean, on a determination nobody recomputed from the register beneath it. The engine re-derives every deadline from the form and the year-end, rebuilds every status from the obligation's own dates, ties each filed row to its evidence and each piece of evidence to a row, ships a planted-defect file for every registered control, and states its benchmark as a command rather than a claim. A deadline missed, or a voucher cut short, is invisible until the notice arrives.

Run it Book a consultation

Architecture

functional block stack · static overview
Structural Precondition Due-Date Re-Derivation Extension Gate & Overdue Fixed-Amount Payment Evidence Tie-Out Roster Completeness Internal Workflow Cross-Year Continuity Status Roll-Up substrate: seeded fictional data

Select a layer

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

Key specifications

at a glance
10,3691
Tests
the collected checks that pin this engine's behavior
222
Controls
independent rules run over every calendar file
93
Families
groups of controls, each answering one question
244
Calendar files
one clean baseline plus twenty-three planted-defect files, one per control
75
Artifacts read
entity roster, due-dates table, obligation register, evidence index, prior-year register, status summary, due-soon watchlist
06
Tolerance
a fixed amount a cent off the statutory constant is a break, not a rounding band

What it does for you

plain terms

A group of entities carries a filing obligation in every jurisdiction it touches, and someone has to prove, entity by entity and obligation by obligation, that each return or payment was filed or validly extended before its statutory deadline, that each fixed-amount voucher went out in the exact amount the statute prints, and that the status register ties to the filed evidence with nothing missing and nothing orphaned. A filing calendar is a matrix of dates that was correct the day someone typed it, and four failures hide inside that, none of which look wrong in a grid of dates. A due date is typed a day off, or an extension offset is keyed to the wrong form, and the whole register chases a deadline that is not the statutory one. An obligation is neither filed nor extended, its deadline slides past the review date, and it sits in the register looking like every other open row until it is a late-filing penalty; a return lodged a day after its applicable due date is late in exactly the same invisible way. A row is marked filed with a receipt number but no voucher was archived, or a voucher sits in the archive with no row that claims it, and the count of done no longer means what it says. The annual LLC tax is a statutory constant, and a voucher cut a cent off it is wrong on its face. None of these are judgment calls. They are equalities and comparisons -- a re-derived deadline against a stored one, a filed date against an applicable deadline with exact <=, a stated amount against the statutory constant, a stated status against its re-derivation -- which a deterministic control settles better than a spreadsheet inherited by whoever tracks filings this year. This is the calendar half of the tax story; preparing the return and computing the tax are separate jobs, and this engine takes the finished calendar and checks only that every deadline was met or validly deferred on time.

The seeded demo runs every control over every calendar file7. The CLI generates twenty-four fictional calendar files -- one clean baseline and one carrying each of the twenty-three planted defects -- then runs all twenty-two 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.

A deadline is met at the date, not a day past it8. A boundary test files a return one day before, exactly on, and one day after its applicable deadline. ext_filed_on_time fires only on the day-after case and stays silent at the deadline and before, because the comparison is exact <= -- a return filed on the applicable due date is on time and a day past it is late, and ext_applicable_overdue uses the same edge for an unfiled obligation whose deadline lands on the review date. There is no grace band.

The status is recomputed, not read back9. A test flips an obligation's stated status to contradict its register dates. rpt_status_recomputes rebuilds the status -- filed, filed-late, overdue, open or not-applicable -- from the obligation's own original and extended due dates and filed date, and fails because the stated determination no longer matches the register, proving the roll-up is recomputed rather than trusted.

Functional block diagram

engineering · each block links to its source
Functional block diagram of the Filing Obligation Calendar engine calendar files complete complete complete complete complete complete complete complete resolves resolves resolves resolves resolves resolves applicable deadline findings findings findings findings findings findings findings findings findings Seeded Calendar Files StructuralPrecondition Due-Date Re-Derivation ExtensionGate & Overdue Fixed-Amount Payment Evidence Tie-Out Roster Completeness Internal Workflow Cross-Year Continuity Status Roll-Up Register, Table& Evidence Verdict and Findings SFS-E25-DUE · FUNCTIONAL BLOCK DIAGRAM · REV 2026-07-24

Plain terms

  • Seeded Calendar Files. fictional fiscal-year filing calendars enter the control registry
  • Structural Precondition. is the calendar file complete and the review date legible
  • Due-Date Re-Derivation. does every due date re-derive from the form and the year-end
  • Extension Gate & Overdue. is the extension gate sound and is anything overdue or late
  • Fixed-Amount Payment. is each fixed-amount voucher the exact statutory constant
  • Evidence Tie-Out. does the register tie to the evidence and the evidence to the register
  • Roster Completeness. is the roster complete and every obligation attributable
  • Internal Workflow. does the internal schedule run in order and on track
  • Cross-Year Continuity. does a final entity stay final across the year boundary
  • Status Roll-Up. does the roll-up recompute from the register
  • Register, Table & Evidence. the register, statutory table and evidence every rule resolves against
  • Verdict and Findings. every finding, with the reason it exists, ends at a person

Engineering

  • Seeded Calendar Files. generate_corpus writes one clean baseline plus one planted-defect file for every registered control, twenty-four files in total. Only the roster, the statutory due-dates table, the obligation base facts and the evidence are stated; each obligation's original and extended due date, its status, the portfolio overdue and filed counts and the due-soon watchlist are derived through the same due-date kernel the engine later recomputes with, so the relationships the engine tests are the same relationships that produced the data.
  • Structural Precondition. One control. FAILs a file missing any of the seven artifact types or carrying a duplicate, and FAILs an unreadable as_of, so no downstream rule holds vacuously on absent evidence.
  • Due-Date Re-Derivation. Four controls: a readable year-end, a row in the statutory table for the (form, year-end), and stored original and extended due dates that re-derive from the table with the extended date the original advanced by the form's whole-month offset.
  • Extension Gate & Overdue. Four controls: the extension flag and extended date agree, nothing is unfiled past its applicable deadline, no filed return was lodged after it, and an unfiled obligation inside the lead window is flagged for chase.
  • Fixed-Amount Payment. One control: the obligation's stated amount equals the statutory fixed amount on the table row for its form, compared with exact equality in integer cents; a malformed amount is contained to its row as AMOUNT_INVALID rather than coerced.
  • Evidence Tie-Out. Three controls: every filed row backed by a voucher, every extension backed by an acceptance, and every piece of evidence pointing at an obligation in the register with a known evidence kind.
  • Roster Completeness. Three controls: every active entity carries a row, every obligation names a rostered entity, and every obligation id is unique so a voucher or status attributes to exactly one obligation.
  • Internal Workflow. Two controls: the prep, review and sent goals run in order and land on or before the applicable deadline, and any actual step completed after its goal is flagged as slippage.
  • Cross-Year Continuity. One control: an entity marked FINAL in the prior fiscal year carries no live obligation this year, resolving the prior-year register against the current obligation register.
  • Status Roll-Up. Three controls: each obligation's stated status re-derives from its register dates, the overdue and filed counts tie the register, and the due-soon watchlist ties the obligations actually due inside the lead window.
  • Register, Table & Evidence. The obligation register carries each obligation's entity, form, year-end, extension flag, stored original and extended due dates, filed date and amount; the statutory due-dates table carries the original offsets and whole-month extension offset and any fixed amount keyed by form and year-end; the evidence index carries every voucher and acceptance keyed to the obligation it proves; the roster and prior-year register carry the completeness and continuity baselines. Due, extension, payment, evidence, roster and roll-up controls all resolve against these, and every applicable deadline is derived through the shared kernel in filing_engine.duedates.
  • Verdict and Findings. Findings roll up per calendar 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
CommandOperationOutputExitArtifacts
python run.py
regenerate the seeded fictional corpus, run all twenty-two controls, write both reportsper-file verdicts and every actionable finding, then the overall verdict2 for the bundled corpus, which carries a planted defect for every control by designfiling_report.json, filing_report.md, samples/
python -m filing_engine samples
analyze an existing folder of calendar files without regenerating itper-file verdicts and findings0 PASS / 1 REVIEW / 2 FAIL / 3 usagenone unless --json or --md is passed
python -m filing_engine samples --generate --quiet
regenerate the corpus and print only the overall verdicta single verdict line0 PASS / 1 REVIEW / 2 FAIL / 3 usagesamples/
python -m pytest
run the full test suite for this engine10369 passed0 when every test passesnone

Benchmarks

measured demo results
MeasureResult
Engine tests1010,369 tests collected
live collection from the engine directory
Registered controls1122 controls
counted from the registry, not from documentation
Planted defects1223 defect files
every registered control has at least one file that trips it
Control coverage13100 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 obligation is treated as met and whether a filing 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

SeverityVerdictAction
No findings above PASSPASScarry the mechanically clean calendar into the documented sign-off and the next filing cycle
One or more FLAG, no FAILREVIEWa human resolves each flag; an unfiled obligation inside the lead window, a slipped internal workflow step and a watchlist that does not tie the register all land here
One or more FAILFAILthe obligation is not treated as met until the failing control is cleared -- a due date that does not re-derive, an overdue or late filing, a fixed amount off the constant, an evidence gap, a roster gap, a recurring final entity, or a roll-up that does not recompute

Operating limits

what it refuses to do

See it run

control architecture
Corporate obligation-matrix architecture for Filing Obligation Calendar: entity and document records pass through jurisdiction and policy controls to verified reporting evidence.
The Filing Obligation Calendar engine tile states the question that has to hold obligation by obligation: every deadline re-derived from the form and the year-end, met or validly extended before it passed, each fixed-amount voucher cut in the exact statutory constant, every filed row tied to evidence and every voucher back to a row, and a status roll-up that recomputes from the register beneath it.

Integration

how to run it

Distribution: public repository, MIT license.

Substantiation
  • 1python -m pytest --collect-only -q -o addopts= (filing-calendar-automation/)
  • 2len(filing_engine.engine.REGISTRY)
  • 3distinct rule-id prefixes in filing_engine.engine.REGISTRY
  • 4samples/*.json after python run.py
  • 5len(filing_engine.model.DOC_TYPES)
  • 6filing_engine/tests/test_control_semantics.py::test_fixed_amount_at_the_cent
  • 7python run.py (filing-calendar-automation/); filing_engine/tests/test_planted_defects.py
  • 8filing_engine/tests/test_control_semantics.py::test_filed_on_the_deadline
  • 9filing_engine/tests/test_control_semantics.py::test_status_must_recompute
  • 10python -m pytest --collect-only -q -o addopts= (filing-calendar-automation/)
  • 11len(filing_engine.engine.REGISTRY)
  • 12len(filing_engine.generate.DEFECTS)
  • 13filing_engine/tests/test_planted_defects.py
  • 14filing-calendar-automation/README.md and filing_engine/tests/test_readonly_and_determinism.py
  • 15filing_engine/model.py DOC_TYPES
  • 16filing_engine/engine.py module docstring (Scope)
  • 17filing_engine/engine.py check_due_original_matches
  • 18filing_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