DEV Community: Marcelo Filho

How the ListaSimples App Works

Marcelo Filho — Fri, 26 Dec 2025 13:35:28 +0000

Introduction
ListaSimples is an application based on legal state governance, and its main purpose is to ensure that internet navigation only occurs when all required information has been correctly filled in.
This governance method allows the system to validate a user's legal state before allowing access to the internet, providing greater security and control over access to websites and services.
In this article, we explain how ListaSimples works step by step and how legal state governance was applied to control internet access in an efficient way.
- -
What Is Legal State Governance?
Legal state governance is a control system based on legal rules that determine whether an action can or cannot be performed, according to the state in which the user currently is.
In other words, before allowing access to a website, the app validates whether the user has provided all required information, such as first name, last name, and other essential data.
- -
How Does the ListaSimples App Work?
ListaSimples applies legal state governance to control internet navigation. The process works as follows:
- -

Filling in the Fields To start the navigation process, the user must fill in three essential fields in the app: First Name Last Name ZIP Code (Postal Code) These fields are mandatory so that the governance system can determine the user's legal state and decide whether internet access is allowed. - -
Governance Process Once the user fills in the fields, the legal state governance validates the information and sends it to the governance system. The system then evaluates the user's legal state and decides whether web navigation is permitted. - -
Access Release When all fields are filled in correctly, the system releases internet access, allowing the user to browse websites and pages normally. - -
Explicit Action The user can only access the internet if all fields are correctly filled in. Otherwise, the system blocks access, preventing any unauthorized navigation. - - Why Is It Important to Fill in All Fields? Legal state governance only works when all required information is properly provided. This prevents users from accessing the internet without supplying the necessary data to ensure authenticity and control. Without complete data, ListaSimples will not allow navigation. - - Example of How It Works
First, the user fills in the first name, last name, and ZIP code. Example: First Name: João Last Name: Silva ZIP Code: 12345–678
The governance system validates the information, checking whether the data is complete and consistent.
If the data is valid, internet access is released. Otherwise, the app blocks any navigation attempt, preventing access to websites. - - Conclusion ListaSimples is a clear example of how legal state governance can be applied to ensure security and control over internet access. By filling in all required fields, the user has their legal state validated and can then browse freely. If the data is incomplete or incorrect, navigation is blocked, protecting both the system and the user from potential security issues.

Video on YouTube: https://www.youtube.com/shorts/f9zyJEn5Yrk
Patent application filed in Brazil
Contact
e-mail: marcelo-editor@hotmail.com
WhatsApp 55 71 988594020

How the ListaSimples App Works

Marcelo Filho — Fri, 26 Dec 2025 01:58:03 +0000

Filling in the Fields To start the navigation process, the user must fill in three essential fields in the app: First Name Last Name ZIP Code (Postal Code) These fields are mandatory so that the governance system can determine the user's legal state and decide whether internet access is allowed. - -
Governance Process Once the user fills in the fields, the legal state governance validates the information and sends it to the governance system. The system then evaluates the user's legal state and decides whether web navigation is permitted. - -
Access Release When all fields are filled in correctly, the system releases internet access, allowing the user to browse websites and pages normally. - -
Explicit Action The user can only access the internet if all fields are correctly filled in. Otherwise, the system blocks access, preventing any unauthorized navigation. - - Why Is It Important to Fill in All Fields? Legal state governance only works when all required information is properly provided. This prevents users from accessing the internet without supplying the necessary data to ensure authenticity and control. Without complete data, ListaSimples will not allow navigation. - - Example of How It Works
First, the user fills in the first name, last name, and ZIP code. Example: First Name: João Last Name: Silva ZIP Code: 12345–678
The governance system validates the information, checking whether the data is complete and consistent.
If the data is valid, internet access is released. Otherwise, the app blocks any navigation attempt, preventing access to websites. - - Conclusion ListaSimples is a clear example of how legal state governance can be applied to ensure security and control over internet access. By filling in all required fields, the user has their legal state validated and can then browse freely. If the data is incomplete or incorrect, navigation is blocked, protecting both the system and the user from potential security issues.

Video on YouTube: https://www.youtube.com/shorts/f9zyJEn5Yrk
Patent application filed in Brazil
Contact
e-mail: marcelo-editor@hotmail.com
WhatsApp 55 71 988594020

Legal State Governance

Marcelo Filho — Thu, 25 Dec 2025 15:01:36 +0000

Governance by Legal State System

Introduction
1.1 Objective of the manual
1.2 What this manual is NOT
1.3 Scope: guardian app only
1.4 Why this system is uncommon
Central Concept of the System
2.1 What is Governance by Legal State
2.2 What is NOT layered governance
2.3 Difference between system permission and legal permission
2.4 The absolute rule: governance decides acts, not screens
Defined Legal States
3.1 INITIAL State
3.2 FIRST_NAME_PRESENT State
3.3 LAST_NAME_PRESENT State
3.4 ZIP_CODE_PRESENT State
3.5 What each state unlocks
3.6 What no state can control
Correct User Flow (No Code)
4.1 App opening
4.2 First permitted navigation
4.3 Progressive field filling
4.4 Automatic evolution of the legal state
4.5 Automatic return of permissions
4.6 What happens when data is deleted
Where Governance MUST Enter
5.1 The "point of the act"
5.2 Governed acts in the app
5.3 Acts that are NOT governed
5.4 Why governance does not enter the layout
5.5 Why governance does not enter the screen lifecycle
Functional Architecture (No Code)
6.1 Separation between UI and legal decision
6.2 UI as a neutral collector
6.3 Legal engine as a black box
6.4 Why the UI does not know rules
6.5 Why the UI does not know domains
WebView and Governance
7.1 Role of the WebView in the system
7.2 WebView is NOT governance
7.3 WebView as a conditioned executor
7.4 Navigation interception
7.5 Why the initial URL always exists
Real Bugs Faced (Technical History)
8.1 White screen (real cause)
8.2 Governance working but without visual perception
8.3 Correct legal state, "frozen" UI
8.4 Fields not reacting in real-time
8.5 Need to close and open the app
Critical Bug: Scroll and Focus
9.1 Why fields "didn't move"
9.2 AndroidView capturing focus
9.3 WebView blocking perceived recomposition
9.4 Classic failure: governance confused with UI
9.5 Final architectural decision
Applied Architectural Correction
10.1 Fully scrollable screen
10.2 WebView integrated into the scroll flow
10.3 Fields always visible and mobile
10.4 Legal state without screen reconstruction
10.5 Governance acting without interfering with UX
Real-Time Update (Legal State)
11.1 What "real-time" means in this system
11.2 What CANNOT trigger total recomposition
11.3 State changes, UI remains
11.4 Permission changes, layout does not
11.5 Navigation reacts without restart
Internet Permissions vs. Governance
12.1 Android Permission ≠ Legal Permission
12.2 Why there is no conflict
12.3 Internet always available
12.4 Governance only restricts acts
12.5 Security without technical blocking
Ethical Principles of the System
13.1 AI does not decide alone
13.2 The guardian is the legal agent
13.3 The system does not "help" when it cannot act
13.4 Transparency without persuasion
13.5 Explanatory blocking, not punitive
Deliberate Limits of the Guardian App
14.1 What the app does NOT do
14.2 What was consciously excluded
14.3 Why there is no automatic recommendation
14.4 Why there is no intelligent adaptation
14.5 Future compatibility with any AI
Final Validation Checklist
15.1 Legal state changes without restarting app
15.2 Scroll works in all scenarios
15.3 Fields never freeze
15.4 WebView never blocks UI
15.5 Governance only acts on the act
Technical Conclusion
16.1 What makes this system unique
16.2 Why there is no ready-made solution
16.3 The common error that was avoided
16.4 What was definitively resolved
16.5 Current state of the project
Introduction
1.1 Objective of the Manual
This manual documents the practical application of the governance by legal state method, using the Lista Simples Appas a reference implementation.
The objective is not to describe a market product, but to record:
• How governance by legal state was applied,
• Which architectural decisions were necessary,
• Which real errors emerged,
• And which corrections allowed the method to function in real execution.
This document is a technical manual of the method, not of a specific application.
TheLista Simples App exists only as experimental support to validate the governance.

1.2 What this Manual is NOT
This manual is not:
• Documentation of a commercial app,
• Marketing material,
• Android or Compose tutorial,
• Generic explanation about LGPD (General Data Protection Law),
• Guide for end-users,
• Nor a comparison between applications.
Everything here exists exclusively to explain governance by legal state in operation.

1.3 Scope of the Document
This manual covers only:
• The governance by legal state method,
• Its direct application in a simple navigation app,
• The relationship between legal state, act, and execution,
• The non-trivial bugs found during this application,
• And the necessary adjustments to ensure real-time reaction.
The manual does not cover other applications, projects, or systems.
Any external mention of the method is irrelevant to this document and has been removed.

1.4 The Role of the Lista Simples App
The Lista Simples Appis not the main object of this manual.
It is:
A minimum execution environment to prove that governance by legal state works without login, without profile, and without persisted permissions.
It was chosen because:
• It reduces variables,
• It exposes failures quickly,
• It forces governance to act in real-time,
• And it eliminates any dependency on backend or authentication.
The app does not represent a final product. It represents a testing ground for the method.

1.5 Why this Method is Not Common
Most systems:
• Control access by user,
• Persist permissions,
• Decide before execution,
• Or delegate the decision to the UI.
This method does none of that.
Here:
• There is no identity,
• There is no session,
• There is no authorization cache,
• There is no "remembered state."
Everything is decided at the moment of the act, based on the current legal state.
This breaks traditional patterns and exposes bugs that common systems do not reveal.

1.6 Fundamental Premise
This manual starts from an absolute premise: Governance by legal state does not control screens. It controls acts. The Lista Simples Apponly exists to prove this premise in real execution.
Every error documented here occurred when this premise was violated — even if subtly.

What is Governance by Legal State (Operational Definition) 2.1 Precise Definition Governance by legal state is a model where no system action is permitted without a valid legal state existing at the moment of execution. Legal state is not: • Technical permission, • Login, • Profile, • Plan, • Saved configuration, • Nor a past decision. Legal state is:A set derived from data declared now, evaluated now, applied now. If the set changes, the state changes. If the state changes, the system reacts.

2.2 What does NOT exist in this model
In this model, there is no:
• Authenticated user,
• Session,
• Authorization cache,
• "Last valid state,"
• Inherited permission,
• Silent fallback.
Each act is evaluated as if it were the first.

2.3 Legal State ≠ Layers ≠ Profile
It is important to make explicit:
• Legal state is not a layer
• Legal state is not a role
• Legal state is not a fixed access level
In theLista Simples App, the legal state is calculated, not chosen.
It arises exclusively from the presence (or absence) of data:
• First Name
• Last Name
• ZIP Code
Nothing more.

2.4 How the Legal State Manifests in the Lista Simples App
In the app, the legal state does not control the UI.
It controls navigation acts.
Conceptual example (without code):
• Act: "navigate to a URL"
• Input: current filled data
• Evaluation: legal state derived from this data
• Result: permit or block the act
The UI only requests the act. It does not know why it was permitted or blocked.

2.5 Existing Legal States in the App
In the Lista Simples App, legal states are progressive and do not persist:
• Initial state → search enabled
• First name present → social networks enabled
• First name + last name → videos enabled
• First name + last name + ZIP code→ full access
These states:
• Are not stored,
• Are not remembered,
• Are not "activated."
They exist only as long as the data exists.

2.6 Real-Time Evaluation (Critical Point)
Governance by legal state re-evaluates at every interaction.
This includes:
• Change in a text field,
• Navigation attempt,
• WebView reload,
• App return from background,
• Screen recreation.
If the state is not re-evaluated in real-time, the method is not correctly implemented.
This point was the origin of several bugs faced.

2.7 Fundamental Difference from Traditional Systems
In common systems:
"The user has permission, so they can."
In this method:
"The act only exists if the legal state allows it now."
There is no accumulated trust. There is only continuous validation.

2.8 Direct Architectural Consequence
This approach forces the system to:
• Separate UI from decision,
• Eliminate implicit state,
• Treat synchronization bugs as critical failures,
• And accept that the app can "change behavior" while it is open.
This is why seemingly simple problems (scroll, white screen, state update) became complex.

Exact Flow of the Method (from Data to Act) 3.1 Central Principle of the Flow In the Lista Simples App, nothing happens by isolated event. Everything happens through a causal chain. The correct flow is always:Data → Legal State → Evaluation → Act (permitted or blocked) If this order is broken at any point, the system enters an inconsistent behavior.

3.2 Origin of the Flow: Data Entry
The flow always starts with data declared by the user:
• First Name
• Last Name
• ZIP Code
This data:
• Is not semantically validated,
• Is not persisted,
• Does not generate direct permission.
It simply exists.
The common error here is treating these fields as a "form." They are not a form. They are a source of legal state.

3.3 Derivation of the Legal State
From the current data, the system derives a legal state.
Important:
• The state is not saved,
• The state is not chosen,
• The state is not confirmed.
It is calculated every time someone tries to do something.
Any attempt to "optimize" this with a cache breaks the method.

3.4 Exact Moment of Governance
Governance does not enter during typing and does not enter during rendering.
It enters only at the moment of the act.
In theLista Simples App, the act is: Attempt to navigate to a URL This is the only legitimate point for a decision. Everything outside of this is an architectural error.

3.5 Evaluation of the Act
When the act occurs, the system evaluates:
• Current legal state
• Requested act (navigate)
• Target of the act (domain)
The possible response is binary:
• Permitted
• Blocked There is no:
• "Almost permitted"
• "Permitted with warning"
• "Permitted but..."

3.6 Execution or Blocking
If permitted:
• The act occurs normally.
If blocked:
• The act simply does not happen.
There is no forced redirection. There is no suggestion. There is no fallback.
The system does not compensate for blocking.

3.7 Continuous Re-evaluation
The above flow occurs:
• Every time the user tries to navigate,
• Even if they have navigated before,
• Even if the legal state was valid seconds ago.
This means:The past does not authorize the present. This is the rule that differentiates the method from any common app.

3.8 Where the Bugs Emerged
The main bugs faced came from violations of this flow:
• Legal state calculated outside the moment of the act,
• UI trying to "help" governance,
• WebView loading before the decision,
• Re-evaluation not triggering due to recomposition failure,
• Layout preventing new interaction (stuck scroll).
None of these bugs are "simple." They are all symptoms of a misplaced flow.

3.9 Golden Rule of the Flow
If you need to summarize the entire method in one sentence: Governance only exists at the exact instant an act is attempted. Any decision before or after that is not governance by legal state.

Where Governance MUST Enter (and Where it CANNOT Enter) 4.1 Absolute Rule of Positioning Governance by legal state does not control the interface, does not control the screen flow, and does not react to visual events. It controls executable acts. In theLista Simples App, there is a single governable act: Navigate to a URL Everything else is support.

4.2 Where Governance MUST Enter
Governance must enter only at the point where the system is about to execute something irreversible.
In the case of the app:
• Before loading a URL,
• Before allowing redirection,
• Before leaving the current domain.
This point is synchronous and deterministic.
Governance responds only:
• Yes
• No Without visual context. Without UI state. Without history.

4.3 Where Governance CANNOT Enter
Governance cannot enter at the following points:
• ❌ At screen creation: If it enters here, it freezes the app and creates empty screens.
• ❌ During field typing: If it enters here, the legal state becomes form validation.
• ❌ In layout or scroll: Governance does not interfere with ergonomics.
• ❌ In Compose recomposition: This creates loops and non-deterministic behaviors.
• ❌ In the Activity lifecycle: This creates disguised persistent state.

4.4 Most Common Architectural Error
The most serious error observed was: Trying to "anticipate" governance. Examples of what went wrong:
• Blocking WebView before the act,
• Trying to unlock access "when the field becomes valid,"
• Loading a URL in LaunchedEffectwithout final validation.
This generates:
• White screen,
• State that only updates upon restart,
• Need to close and open the app.

4.5 UI is Blind by Definition
The UI:
• Does not know rules,
• Does not know domains,
• Does not know legal states,
• Does not decide anything.
It only:
• Collects data,
• Requests acts,
• Executes the response.
Any logic beyond this in the UI is a direct violation of the method.

4.6 Governance Does NOT Replace System Permissions
Important:
Governance does not interfere with:
• Internet permission,
• Network permission,
• Android permissions.
It assumes the operating system already allows the technical act.
If technical permission fails, that is not governance. It is an infrastructure error.
Mixing the two creates false diagnoses.

4.7 Final Correct Point (Summary)
Governance enters:
• ✔️ Immediately before loadUrl It does not enter:
• ❌ Before the screen exists
• ❌ During typing
• ❌ During layout
• ❌ During rendering

4.8 Direct Consequence of This Choice
Because of this positioning:
• The legal state can change in real-time,
• The app does not need to be restarted,
• There is no "remembered" permission,
• Bugs appear early (and are real).
This is not a defect. It is proof that the method is correct.

Real Errors Faced (and why they were NOT simple) 5.1 Why These Errors Do Not Appear in Common Apps In traditional applications: • Permissions are persisted, • Decisions are made once, • States do not change during execution, • UI "commands" the behavior. Here, none of that exists. The system is reactive, non-persistent, and legal-executable. This exposed errors that are normally hidden.

5.2 Error 1 — White Screen (the most critical)
Symptom
• WebView appears empty,
• No automatic navigation,
• App seems "without internet." Real Cause The WebView was created without executing a valid initial act. Governance was correct, but no act was requested. Why it is not simple In common apps, the WebView loads something "by default." Here, no default is allowed without passing through the legal state. Conceptual Correction
• Every valid legal state needs to generate an explicit act.
• The WebView cannot exist without a navigation intention.

5.3 Error 2 — "Does not access the internet automatically"
Symptom
• Permissions in Manifest are correct,
• Internet works in other apps,
• Only navigates after restarting or clicking several times. Real Cause Race condition between:
• WebView creation,
• Legal state calculation,
• Navigation attempt.
Governance was right, but the architectural timing was wrong.Why it is not simple It's not permission. It's not DNS. It's not a broken WebView. It's an execution order error, typical of pure reactive systems.

5.4 Error 3 — Legal State Does Not Update in Real-Time
Symptom
• Filling in First Name / Last Name / ZIP Code,
• State only changes after closing the app.

Real Cause Governance was being consulted:
• In the wrong cycle,
• Or at more than one point,
• Or linked to the UI, not the act. Conceptual ErrorConfusing:
"Legal state changed" with "Act needs to be re-evaluated."
Governance does not react to change. It reacts when an act is requested.

5.5 Error 4 — Stuck Fields / No Scroll
Symptom
• Fields do not move up with the keyboard,
• Cannot scroll,
• Layout seems "frozen." Real Cause The governance system did not cause this, but it exposed a classic Compose error:
• Fixed layout,
• WebView occupying total weight,
• Absence of a scrollable container. Why it seems like governance Because the app only "broke" when the state changed. In reality, it was the recomposition revealing the error.

5.6 Error 5 — Governance Mixed with UI
Symptom
• Duplicated logic,
• Rules in more than one place,
• Inconsistent behavior. Real Cause Initial attempts to:
• Validate domains on the screen,
• Anticipate blocks,
• "Help" governance. Why it is serious This breaks the principle: UI is neutral. Governance is blind. When mixed:
• Decisions cease to be deterministic,
• Bugs become intermittent,
• The system loses legal reliability.

5.7 Error 6 — Legacy Files Breaking Build
Symptom
• Compilation error,
• Non-existent references,
• Nothing related to the UI. Real Cause Old governance files:
• Old state names,
• Removed enums,
• Logic already replaced.
Even if not used, the compiler does not ignore them.Conceptual Correction Governance does not admit active legacy. It either exists or it doesn't.

5.8 Common Pattern Among All Errors
No error was:
• Lack of permission,
• Simple bug,
• Typing error.
All were:Subtle violations of the correct decision point. Either governance entered too early, or too late, or in the wrong place.

5.9 Central Lesson of This Section
If governance:
• Controls screens → it breaks.
• Controls layout → it breaks.
• Controls forms → it breaks.
• Controls timing → it breaks.
It only works when:It controls acts, and only acts.

Governance × System Permissions (Android) 6.1 Central Principle In the Lista Simples App: Technical permission is not legal authorization.Android grants permission. Governance authorizes the act of asking. These two things never mix.

6.2 The Classic Error (that almost happened)
The common — and dangerous — error would be:
• Trying to "control internet" through governance,
• Trying to block Android from accessing the network,
• Thinking that the legal state "activates" the internet.
This is not possible and not desirable.
The internet:
• Is not a feature,
• Is not a privilege,
• Is a system resource.

6.3 What Governance Really Controls
Governance does not control the permission. It controls the use of the resource.
In theLista Simples App:
• The INTERNET permission is always granted.
• Governance decides if navigation is a valid act. Result:
• Internet available.
• Navigation legally conditioned.

6.4 Why This Caused Real Confusion
During development, the feeling arose that:
"The app didn't ask for internet permission."
In reality:
• Permission was already granted.
• What was blocked was:
◦ Initial loading,
◦ Default URL,
◦ Legal state reactivity.
In other words: it looked like permission, but it was flow.

6.5 Where Governance Enters (Exact Point)
In the Lista Simples App, governance enters only here: At the moment of the ACT of navigation. It evaluates:
• URL
• Current legal state
• Current rule
And responds only:
• ✅ Permitted
• ❌ Blocked Nothing more.

6.6 What was Learned from the Bugs
The bugs showed that:
• Governance cannot live in the UI,
• Governance cannot live in the manifest,
• Governance cannot "simulate permission."
It needs to exist:
• As a synchronous decision,
• At the exact moment of the action,
• Without memory,
• Without cache,
• Without exceptions.

6.7 Correct Final Result
In the final state of the Lista Simples App:
• ✅ Internet always available
• ✅ Governance always active
• ✅ Legal state re-evaluated in real-time
• ✅ No "fake" permissions
• ✅ No conflict between Android and governance
The system became legally coherent and technically clean.

Correct Execution Flow of the Lista Simples App 7.1 Flow Principle The Lista Simples Appdoes not have a fixed start. It does not "start blocked." It does not "wait for registration." It does not "activate features." It reacts continuously to the current legal state.

7.2 App Opening (Initial State)
Upon opening the app:
• No data has been provided,
• No field has been filled,
• No action has been requested.
Resulting legal state:INITIAL Capability: SEARCH_ONLY Important:
• The app can already navigate,
• The WebView must already exist,
• Search must already work.
• ❌ No empty screen. ❌ No "wait for filling."

7.3 UI Initialization
At initialization:
• The fields (First Name, Last Name, ZIP Code) are displayed,
• The WebView is created immediately,
• An initial URL compatible with the legal state is loaded.
This point was critical:
• If the WebView does not load something here → white screen.
• If it depends on the user clicking → flow error. Applied correction:
• Default URL loaded upon creation.
• Do not depend on human events.

7.4 Data Entry (Live Flow)
When the user types:
• First Name
• Last Name
• ZIP Code
What happens:
• No button is pressed,
• No explicit action is requested,
• No permission is asked.
But internally:
• The legal state changes,
• The capability changes,
• Permitted navigation changes.
Everything in real-time.

7.5 Automatic Re-evaluation of the Legal State
Every character typed triggers:
• Re-evaluation of the legal state,
• Update of the navigation mode,
• Immediate adjustment of what can or cannot be accessed.
There is no:
• "Save"
• "Confirm"

The system does not trust intentions, only the current state.

7.6 Act of Navigation (Critical Point)
Every navigation goes through:
• Typing a URL,
• Clicking on links,
• Automatic redirections.
For each attempt:
• Governance is consulted,
• The decision is made on the spot,
• There are no exceptions.
This is the only point where governance acts.

7.7 Downgrade is as Important as Upgrade
If the user:
• Deletes the first name,
• Deletes the last name,
• Deletes the ZIP code.
The legal state regresses immediately.
Consequences:
• Previously accessible content becomes blocked,
• There is no "active session,"
• There is no "last authorization."
This was intentional.

7.8 App Closure
Upon closing the app:
• No state is saved,
• No permission is remembered,
• No decision persists.
Upon opening again:
• Everything starts from scratch,
• The system is clean,
• The legal state needs to be reconstructed.

7.9 Flow Result
The final flow proves that:
• Governance can be reactive,
• Governance can be continuous,
• Governance can coexist with simple UX,
• Governance does not need a backend,
• Governance does not depend on login.
And mainly:The system never "helps." It only executes permitted acts.

Governance by Legal State in the Lista Simples App 8.1 Purpose of Governance in the App In the Lista Simples App, governance by legal state exists to control navigation acts, not screens, not users, and not technical permissions. The objective of the app is not full navigation, but to demonstrate that:A system can execute or block actions exclusively based on the current legal state, recalculated in real-time. The app serves as functional proof of the method.

8.2 What is "Legal State" in this App
The legal state is a derived, non-persisted state, calculated from data declared in the UI itself:
• First Name
• Last Name
• ZIP Code
This data does not identify a user; it legally enables progressive acts.
There is no:
• Login,
• Registration,
• Session,
• Profile,
• Authorization history.

8.3 Defined Legal States
The system operates with four possible legal states:
• INITIAL: No data → access only to search.
• FIRST_NAME_PRESENT: First name provided → access to social networks.
• LAST_NAME_PRESENT: First name + last name → access to videos.
• ZIP_CODE_PRESENT: First name + last name + ZIP code → full access.
Each state is not a user level; it is a momentary legal condition.

8.4 Where Governance "Enters" the System
Governance enters exactly at the point of the act, and only there.
In the app, the act is:Attempting to navigate to a URL. Governance does not act on:
• Screen rendering,
• Layout,
• Scroll,
• Text fields,
• Activity lifecycle.
It acts only when an act is requested.

8.5 How the Control Works in Practice
Logical flow:
1 The UI collects data (first name, last name, ZIP code).
2 The legal state is recalculated immediately.
3 The user attempts to navigate.
4 The Engine receives:
◦ Requested URL,
◦ Current legal state.
5 The Engine responds:
◦ Permitted
◦ Or Blocked.
The UI does not know why. It only executes or does not execute.

8.6 Why There is No Permission Cache
There is no:
• "Already permitted before,"
• "Last valid authorization,"
• "Saved state."
If the user:
• Deletes the first name → loses access to social networks.
• Deletes the last name → loses access to videos.
• Deletes the ZIP code → loses full access.
This can happen while the app is open. This behavior is intentional.

8.7 Difference from Android Technical Permissions
Android permissions (e.g., INTERNET):
• Are technical,
• Are global,
• Do not change in real-time,
• Do not know legal context.
Governance by legal state:
• Is logical,
• Is contextual,
• Changes in real-time,
• Controls what can be done, not what can be technically accessed.
Therefore, there is no conflict between governance and operating system permissions.

8.8 Important Architectural Consequence
This model exposes problems that common apps do not face:
• Screens that do not react automatically,
• WebView that does not reload on its own,
• Scroll blocked by incorrect layout,
• Visual state divergent from the legal state.
These problems are not governance bugs. They are bugs that governance reveals.

Real Problems Encountered During Implementation This section documents only real problems faced during the development of the Lista Simples App, caused or revealed by governance by legal state. None of the problems below are "beginner" issues. All arise because the system does not follow common patterns.

9.1 The False Problem of "Internet Permission"
Observed Symptom
• The app "does not access the internet automatically,"
• WebView appears blank,
• No permission popup is displayed. Deep Investigation
• INTERNET and ACCESS_NETWORK_STATE permissions were correct,
• Declared outside the tag,
• Build and Manifest were correct. Real Cause
• The WebView was not being instructed to load a valid initial URL at the right time.
• It was not a permission problem.
• It was an execution order problem. Why this is not common
• In traditional apps, the URL is fixed.
• Here, the URL depends on the legal state, which changes in real-time. Conceptual Correction The WebView can only load after:
6 Legal state is defined.
7 Default URL derived from that state exists.

9.2 Intermittent White Screen
Observed Symptom
• App opens,
• UI appears,
• WebView stays white,
• Only works after closing and opening again. Real Cause
• WebView created before the final legal state.
• The legal state changed, but the WebView did not react. Discarded Common Error
• It was not cache.
• It was not JS.
• It was not HTTPS. Conceptual Correction
• The WebView needs to react to changes in the legal state.
• The legal state cannot be calculated after the creation of the WebView.

9.3 Legal State Not Updating in Real-Time
Observed Symptom
• Fill in first name,
• Access does not change,
• Need to close the app, open again, and fill in again. Real Cause
• The legal state was correct.
• The UI was not reacting correctly to the change. This happens because:
• Governance by legal state breaks the idea of a "fixed initial state."
• Compose needs to be explicitly reactive. Important: This problem does not appear in apps with login because the state is loaded only once.

9.4 Text Fields Not Moving the Screen (Stuck Scroll)
Observed Symptom
• First name, last name, and ZIP code fields do not move,
• Keyboard covers the fields,
• Not possible to scroll down. Real Cause
• Layout designed as a fixed screen.
• Governance requires continuous interaction.
• The UI was not prepared for fields that alter legal state in real-time. Discarded Error
• It was not a keyboard bug.

It was an incompatible layout architecture.

9.5 Governance Acting in the Wrong Place (Initial Critical Error)
Initial Symptom
• Attempt to block UI,
• Attempt to hide fields,
• Attempt to condition screens. Why it failed
• Governance does not control screens.
• Governance controls acts. Structural Correction
• Fields always visible,
• Screen always the same,
• Governance only acts when:
◦ A navigation is requested.

9.6 Legacy Files Breaking Build
Observed Symptom
• Build failing,
• Non-existent enum errors,
• References to old states. Real Cause
• Old governance files still present.
• Even if not used, they broke the compilation. Lesson Learned In legal architecture, a dead file is an active risk.

9.7 The Most Important Bug: "Too Good" Governance
Conceptual Problem
• The system was correct,
• But it seemed "not to work." Reason
• The user expects persistent permissions.
• The system removes permissions instantly. Hard Conclusion Correct governance looks like a bug to those who expect comfort.

Architectural Decisions Taken (and why) This section documents conscious decisions, not improvisations. Each choice here was made because common solutions failed in the face of governance by legal state.

10.1 Legal State as the Single Source of Truth
Decision: Every app behavior derives exclusively from the current legal state. Why:
• Login creates artificial persistence.
• Session creates undue memory.
• Cache creates implicit authorization.
The legal state is always calculated, never remembered.

10.2 Fully Neutral UI
Decision: The UI does not know rules, domains, permissions, or exceptions. Why:
• UI cannot "understand" the law.
• UI only requests acts.
• Decision outside the UI avoids logical leaks. Result: The UI asks → the legal engine responds → the UI obeys.

10.3 Governance Acts Only on the Act
Decision:Governance does not act on fields, screens, or layout.
It acts only when:
• A navigation is requested,
• A URL is about to be loaded. Why: Governance that controls UI becomes UX disguised as law — this is invalid.

10.4 Search Always Enabled (Initial State)
Decision: The app always starts with access to search. Why:
• Search is a minimum utility.
• Does not require personal data.
• Avoids a "dead" app on first use.
This establishes a functional, non-punitive state of rest.

10.5 Legal Progression, Not Technical Progression
Decision: First Name → social networks; Last Name → videos; ZIP Code → full access. Why:
• It is not gamification.
• It is not a reward.
• It is a proportional expansion of capability.
Each piece of data delivered alters the legal state; it does not "unlock a feature."

10.6 Continuous Re-evaluation (No Persistence)
Decision: No permission is stored. Why:
• Stored permission becomes an acquired right.
• Acquired right violates governance.
If the data disappears, the access disappears. Immediately.

10.7 WebView Under Legal, Not Technical, Control
Decision: The WebView decides nothing. Why:
• WebView is an escape vector.
• Without control, it becomes unrestricted internet.
Every navigation passes through legal validation before occurring.

10.8 Single Layout, Variable State
Decision: A single screen for the entire flow. Why:
• Multiple screens create implicit state.
• Implicit state breaks traceability.
Here:
• Screen is constant.
• Behavior changes.

10.9 Governance Does Not "Help" the User
Decision: The system does not suggest, guide, or explain alternative paths. Why:
• Helping is deciding.
• Deciding is a human role.
Governance only:
• Permits,
• Or blocks.

10.10 Accept Discomfort as a Sign of Correctness
Decision: Do not smooth out "strange" behaviors. Why:
• Real governance is not comfortable.
• Excessive comfort indicates implicit permission.
If it seems rigid, it is working.

Case Study: INSS Fraud and the Impact of Governance by Legal State 11.1 Problem Context (Real World) Recurrent frauds in the INSS (National Social Security Institute) did not occur due to a lack of systems or technology. They occurred because the current model is based on: • Static technical permissions, • Long-lasting administrative profiles, • Authorizations that survive time, • Institutional trust instead of continuous verification. The system presumes legitimacy after an initial point. This is the structural error.

11.2 Where Fraud Forms (Root of the Problem)
In traditional INSS systems:
• A server has access because they "have a position."
• A system executes because it is "authorized."
• A benefit is granted because it "passed through a stage."
In other words:
👉 The act is not validated at the moment of execution.
👉 Legality is presumed, not recalculated.
Fraud is born exactly there.

11.3 How Governance by Legal State Would Change the Game
If governance by legal state were implemented, the system would work like this:
• No act would exist by profile.
• No access would exist by position.
• No action would exist by history.
Each action would require:A valid legal state at that exact moment. No state → no act. No exception. No memory.

11.4 Practical Example — Granting a Benefit
Current system (simplified):
8 Server accesses the system.
9 Fills in data.
10 Executes the grant.
11 System accepts. With governance by legal state:
12 Request for grant is an act.
13 The system verifies:
◦ Legal link of the applicant,
◦ Legal existence of the benefit,
◦ Integrity of the data at the moment,
◦ Absence of conflict or block.
If any element is missing: ❌Act blocked. Even if the server has "permission."

11.5 Why Fraud Does Not Scale in This Model
Fraud needs repetition. Governance by legal state prevents this because:
• There is no reusable permission,
• There is no long-lasting access,
• There is no operational "shortcut,"
• Each execution is legally isolated.
A fraudster would have to:
• Reconstruct the complete legal state,
• For every action,
• Without failure.
This makes fraud economically unviable.

11.6 Fundamental Difference: Control of Acts vs. Control of People
The INSS today controls who can do it. Governance by legal state controls if the act can exist.
This difference is structural. Frauds are not committed only by "wrong people," but by acts that should never have been possible.

11.7 Why This Is Not Used Today
Because this model:
• Breaks traditional hierarchies,
• Eliminates "operational autonomy,"
• Requires legal engineering in the code,
• Exposes hidden failures,
• Generates institutional discomfort.
It is technically possible. It is politically difficult.

11.8 Direct Relationship with the Lista Simples App
The Lista Simples App proves, on a minimum scale, that:
• Access can exist without login,
• Permissions can be volatile,
• The system can self-block,
• The decision can always be recalculated.
What in the app controls URLs, in the INSS would control administrative acts. The principle is the same. Only the impact changes.

If governance by legal state were present:
• Fraud would not "go unnoticed,"
• It would not be able to exist,
• Not through surveillance,
• But through structural impossibility.
The system would not detect fraud. It would not permit the fraudulent act.

Internet Permissions vs. Governance 12.1 Android Permission ≠ Legal Permission Android's INTERNETpermission is technical. It only tells the operating system: "This application can open network connections." It does not decide: • Where the app can go, • When it can access, • In what context, • Under what legal conditions. Governance by legal state acts above this.

12.2 Why There is No Conflict
There is no conflict because the two mechanisms do not compete.
• Android → grants technical capability.
• Governance→ grants legal authorization for an act.
Even with internet enabled by the system:
• The app can be legally blocked.
• Navigation can be denied in real-time.
Governance does not try to block the internet. It blocks theuse of the internet for certain acts.

12.3 Internet Always Available
In the Lista Simples App:
• The INTERNET permission is always active.
• There is no dynamic permission request.
• The system never turns the network on/off.
This is intentional. If governance tried to request permission, revoke permission, or interfere with the operating system, it would cease to be legal and become technical.

12.4 Governance Only Restricts Acts
What governance does, in practice:
14 Evaluates the current legal state.
15 Receives an act (e.g., navigate to a URL).
16 Responds only: Permitted or Denied.
It does not:
• Create exceptions,
• Store permissions,
• "Remember" past decisions.
Each act is judged at the moment of execution.

12.5 Security Without Technical Blocking
This model generates an important effect:
• The app remains functional,
• The system remains fluid,
• There are no permission errors,
• There are no broken screens.
And yet:
• Undue acts do not happen,
• Undue accesses do not execute,
• Attempts do not leave an exploitable technical trail.
This is security through legal execution, not through brute blocking.

Ethical Principles of the System 13.1 AI Does Not Decide Alone In this system, no decision is made by "intelligence." The AI (or any automated logic): • Does not interpret intention, • Does not make subjective judgments, • Does not "understand context," • Does not choose exceptions. It only executes a decision that has already been legally determined by the current legal state.

13.2 The Guardian is the Legal Agent
The only agent with real power in the system is the guardian who provides the data.
The system assumes that:
• Declared data = manifestation of legal will.
• Absence of data = absence of authorization.
• Removal of data = immediate revocation.
There is no:
• Implicit consent,
• Inherited consent,
• Permanent consent.

13.3 The System Does Not "Help" When It Cannot Act
When an act is denied, the system:
• Does not suggest alternatives,
• Does not bypass,
• Does not guide on how to "unlock,"
• Does not induce filling.
It only informs that the act cannot be executed in that legal state. This is deliberate.

13.4 Transparency Without Persuasion
The system is transparent but not persuasive.
It can:
• Inform that something is blocked,
• Indicate that the current legal state does not allow the act.
It cannot:
• Convince the user,
• Pressure a decision,
• Create a sense of loss,
• Induce behavior.

13.5 Explanatory Blocking, Not Punitive
When there is a block:
• There is no technical error,
• There is no punishment,
• There is no "accusatory" log,
• There is no persistent negative state.
The block exists only as long as the legal state does not allow the act. As soon as the state changes, the block disappears. No history. No penalty. No memory.

Deliberate Limits of the Guardian App 14.1 What the App Does NOT Do This app does not try to be complete. It deliberately does not: • Make personalized recommendations, • Interpret sensitive data, • Calculate risk, • Classify behavior, • Predict intention, • Suggest decisions. Any attempt at "intelligence" here would break the governance.

14.2 What was Consciously Excluded
The following were excluded from the start:
• Traditional login and authentication,
• Persistent profiles,
• Navigation history,
• Consent storage,
• Authorization memory,
• User preferences.
None of this is compatible with pure governance by legal state.

14.3 Why There is No Automatic Recommendation
Recommendation implies judgment. Judgment implies interpretation. Interpretation implies a decision outside the legal state.
Therefore:
• The system never "recommends,"
• Never "indicates the best,"
• Never "guides the next step."
It only permits or prevents acts.

14.4 Why There is No Intelligent Adaptation
Adaptation does not exist because:
• Adaptation requires memory,
• Memory creates continuity,
• Continuity creates implicit permission.
This system works by absolute present. Each act is evaluated as if it were the first.

14.5 Future Compatibility with Any AI
Precisely because it does not contain interpretive logic, the system is compatible with:
• Any AI model,
• Any decision engine,
• Any future interface.
The AI never receives power. It only consults the legal state. Governance remains superior.

Final Validation Checklist This checklist exists to validate if governance by legal state is truly implemented and not just "visually working." It must be executed with the app open, without restarting, without clearing data, and without shortcuts.

15.1 Legal State Changes Without Restarting the App
• Fill in First Name → state changes immediately.
• Fill in Last Name → new state immediate.
• Fill in ZIP Code → full access immediate.
• Delete any field → state regresses on the spot.
• ❌ If you need to close the app → governance failed.
• ❌ If it depends on a "confirm" button → governance failed.

15.2 Scroll Works in All Scenarios
• Fields remain accessible with WebView loaded.
• It is possible to scroll up and down.
• The keyboard does not "freeze" the screen.
• No field becomes inaccessible.
• ❌ If the scroll freezes → UI architecture error. Not a governance problem.

15.3 Fields Never Freeze
• TextFields always editable.
• Focus changes normally.
• No field "disappears" after navigation.
If it freezes: the UI is competing with the WebView. Governance does not interfere with this.

15.4 WebView Never Blocks UI
• WebView does not capture focus permanently.
• WebView does not prevent perceived recomposition.
• WebView only executes authorized navigation.
If the UI seems frozen: the error is layout/scroll, not legal state.

15.5 Governance Only Acts on the Act
Validate that:
• Governance does not decide layout,
• Governance does not create internal navigation,
• Governance does not trigger recomposition.

It acts only when an act occurs: Navigation attempt.

15.6 Technical and Legal Permissions are Independent
• INTERNET always granted.
• ACCESS_NETWORK_STATE always granted.
• No permission changes at runtime.
If the internet "disappears": the problem is not governance.

15.7 No Rules are in the UI
Validate that:
• UI does not know domains,
• UI does not know states,
• UI does not know criteria,
• UI only displays the current state.
If the UI "knows too much": the architecture has leaked.

15.8 No State is "Half-Valid"
• There is no undefined intermediate state.
• There is no silent fallback.
• There is no last valid state.
Each act is validated from scratch.

15.9 Correct Failure is Blocking, Not Error
When something cannot happen:
• It does not break.
• It does not crash.
• It does not try to correct.
• It does not suggest an alternative.
It only blocks and explains.

Application of the Method: Windows (Technical Hypothesis) This section demonstrates why governance by legal state drastically reduces the viability of attacks, even in traditionally vulnerable environments like Windows. This is not marketing; it is architectural analysis.

16.1 Why "Hacking Windows" is a Good Conceptual Test
Windows is a target because:
• It executes critical acts (installation, execution, file access),
• It trusts persistent technical permissions,
• It poorly separates intention from execution.
In other words: it is the exact opposite of the legal state model.

16.2 Where Attacks Normally Happen
Attacks exploit:
• Permissions granted once,
• Implicit states ("logged-in user"),
• Trust in previous context,
• Automatic execution post-installation.
None of this exists in the legal state model.

16.3 How the Legal State Changes the Game
In the governance by legal state model:
• No action is valid "because it was already permitted before,"
• No act occurs without revalidation,
• There is no silent execution,
• There is no historical trust.
Each act asks:"Does this legal state authorize this now?"

16.4 Conceptual Example (No Code)
Traditional act in Windows: Execute an installer. In the legal state model:
• Executing is a legal act, not a technical one.
• Requires a valid state at the exact moment.
• Any change invalidates the act. Result:
• Malicious automation loses continuity.
• Scripts break.
• Exploits become inconsistent.

16.5 Why Malware Does Not Adapt Well to This
Malware depends on:
• Predictability,
• Repetition,
• Persistent permissions,
• Chain execution.
Governance by legal state breaks:
• Predictability (state changes),
• Repetition (act is not reusable),
• Chain (each step revalidates).

16.6 Important: This is NOT an Antivirus
This method:
• Does not detect malware,
• Does not analyze behavior,
• Does not block binaries.
It removes the fertile ground where attacks work.

16.7 Practical Result
With governance by legal state:
• Automated attacks become unstable,
• Social engineering loses cumulative effect,
• "Clicking once" is not enough,
• Persistence becomes unlikely.
Not impossible — but statistically unviable.

16.8 Conclusion of this Section
If even an environment like Windows conceptually benefits from this model, it proves that:
• The method is not app-specific,
• It does not depend on mobile,
• It does not depend on WebView,
• It is a general architectural principle.

Technical Conclusion 17.1 What was Really Built The Lista Simples App is not a common browser. It is functional proof that governance by legal state works in practice, in real-time, without a backend, without login, and without persistent permissions. Nothing was simulated. Everything was faced in real code, with real bugs.

17.2 What Makes This System Unique
This system proves that it is possible to:
• Control access without authentication,
• Control navigation without profiles,
• Control permissions without memory,
• Govern acts without controlling screens.
This is not common because it breaks the traditional logic of apps.

17.3 The Classic Error that was Avoided
The most common error — which almost happened several times — would be:
• Mixing governance with UI,
• Blocking layout thinking it is blocking an act,
• Using recomposition as control,
• Using technical permission as legal permission.
Each bug faced served to reinforce the correct separation.

17.4 What was Definitively Resolved
This project resolved, in a proven way:
• White screen due to poorly initialized WebView,
• Correct legal state without visual reaction,
• "Frozen" recomposition due to WebView focus,
• Fields that did not react in real-time,
• Need to restart the app to update permissions,
• Confusion between internet permission and legal permission.
None of this was resolved with a "workaround." It was resolved architecturally.

17.5 Real Value of the Method
The value of this system is not in the app itself. It lies in the fact that:
• Governance is independent of technology,
• The method scales to any domain,
• The risk of fraud drops drastically,
• The AI (or any executor) is subordinate to legality.
This places this model on the same conceptual level as layered governance — but with direct, lightweight, and verifiable practical application.

17.6 Current State of the Project
• Governance by legal state: Implemented
• Real-time update: Functional
• Architecture: Stable
• Critical bugs: Resolved
• Scope: Deliberately simple
• Purpose: Technical proof of the method
The system is ready as a reference. Not for the market yet, but to show that it is possible.

Patent application filed in Brazil
Contact
e-mail: marcelo-editor@hotmail.com
WhatsApp 55 71 988594020

Legal State Governance

Marcelo Filho — Thu, 25 Dec 2025 08:12:11 +0000

Simple Explanation (for anyone)

Imagine a system that is always running.

Nothing disappears from the screen.
Nothing breaks.
Nothing restarts.

The system does not constantly interfere with what you are seeing.

Only one thing happens:

When a person tries to perform a new action, the system checks whether that action is allowed.

If it is allowed:

the action happens normally.

If it is not allowed:

the action simply does not occur.

No warning screens.
No errors.
No white screens.

The system does not control the user continuously.
It only evaluates new actions, exactly at the moment they are requested.

Technical Explanation (for developers)

The problem with traditional models

Most systems implement governance like this:

legal state changes
→ UI reacts
→ components are recreated
→ side effects appear

This mixes governance, execution, and interface.

The result is instability, recomposition loops, and unpredictable behavior.

The correct model: governing actions, not states

In Legal State Governance:

Legal state changes do not trigger execution

Only explicit human actions are evaluated

Architecturally:

Layer Responsibility

Governance Decides whether an action is allowed
Executor Executes the action if allowed
Interface Displays the current state

No layer leaks into another.

The concept of Explicit Human Action

Every sensitive operation must pass through a single, explicit checkpoint:

Button(onClick = {
if (governance.allows(action)) {
executor.execute()
}
})

This is the only authorized place to execute something meaningful.

There is no:

automatic execution

hidden side effects

implicit navigation

Practical application (WebView)

The WebView is created once

It starts in a neutral state (about:blank)

Governance never manipulates the WebView itself

Navigation only happens after a human click

Interception occurs only here:

shouldOverrideUrlLoading()

And it evaluates:

intent (domain)

legal context

Not the full technical URL.

Why this model is robust

Eliminates white screens

Prevents recomposition loops

Supports legal downgrades without disruption

Preserves system predictability

From an engineering standpoint:

The system becomes deterministic because it reacts only to human actions.

One-sentence summary

Simple:
The system only decides when you try to do something new.

Technical:
Governance operates exclusively at explicit action points, never on passive state changes.

Patent application filed in Brazil
Contact
e-mail: marcelo-editor@hotmail.com
WhatsApp 55 71 988594020