Raw contract text
The analyzed text is not written into the analysis-usage table as a retained document. The uploaded binary is parsed into text for the request and the extraction route itself has no persistence layer.
Data Policy. POOF.
Process Once. Output. Finished.
Focus is designed to do the work, return the result, and avoid turning your contract into a permanent application record. Your document is processed for the analysis; the reports and findings are made to leave with you.
INPUTYour contract text
PROCESSDeterministic computation
OUTPUTPortable reports + proof
PERSISTENCENo raw contract record stored by the analysis layer
COMPUTATIONAL COMPILER
The contract is treated as input to a computation, not as a document to keep.
Focus receives the text, evaluates it against a versioned deterministic rule registry, constructs an ordered occurrence ledger, builds proof material, and returns the result. In the current contract engine, that chain is the IGI baton sequence: source custody → registered lexical authority → exact occurrence detection → ordered occurrence ledger → deterministic proof.
The engine itself is a pure deterministic function. It does not call an LLM to decide what a term means, where it appears, or whether it should be recognized. Given the same source text and the same registry version, the engine is designed to return the same structured result and the same proof hashes.
01Source custody
Exact text enters the request path. No semantic rewriting or generative preprocessing is required.
→
02Rule registry
The current versioned term registry supplies the authorized deterministic rules for the run.
→
03Occurrence ledger
Exact matches are anchored to source positions and ordered into a reproducible findings ledger.
→
04Proof output
Input, registry, occurrence, and deterministic-output hashes are generated with the result.
WHAT PERSISTS — AND WHAT DOES NOT
There is persistence for accounting. There is not a raw contract archive.
A secure system should be precise about this. Focus does retain limited metadata needed to meter usage and recognize an exact contract rerun. It does not store the raw contract text in the analysis-usage database.
Usage and identity metadata
The system records the Clerk user ID, an idempotency key, the UTC usage period and slot, plus a keyed document fingerprint so the same contract can be recognized as a rerun.
Keyed HMAC fingerprint
Focus computes HMAC-SHA-256 over the exact analyzed text using a server-side secret. The stored digest is not the document and is not reversible. Without the secret, a database holder cannot simply hash a candidate contract and test whether you submitted it.
Request and runtime memory
The text necessarily exists while the server extracts and analyzes it. That transient processing is different from retaining the document as an application record after the run.
WHY THE FINGERPRINT EXISTS
Recognize the same contract without keeping the contract.
Focus currently counts new contracts for usage purposes while allowing an exact contract you have already analyzed to be recognized as a rerun. To do that without storing the contract body, the server computes a keyed fingerprint over the exact text.
One character different produces a different fingerprint. No whitespace, case, or Unicode normalization is performed before the fingerprint is computed. That is intentional: exact input identity stays exact.
The fingerprint and the deterministic engine serve different jobs. The fingerprint answers “has this user submitted this exact text before?” The engine answers “what does this version of the deterministic rule system produce from this text?” Neither substitutes for the other.
FILE HANDLING
Files are reduced to text before the contract engine sees them.
PDF, DOCX, TXT, and Markdown uploads are accepted by a dedicated extraction route. The route validates the file, reads it into server memory, extracts UTF-8 text, and returns that text to the application. The extraction route does not score the contract, does not contact the engine, and does not persist the uploaded file.
Once the text is in the analysis request, the contract engine works on that text. This keeps binary-file parsing separate from deterministic contract evaluation and reduces the number of components that need access to the source material.
WHY THIS ARCHITECTURE MATTERS
Security is easier to reason about when storage is not the default behavior.
Every permanent data store creates another retention policy, another access-control surface, another deletion problem, and another place sensitive information can accumulate. Focus keeps the contract-analysis path narrow: receive, compute, return.
That does not mean “nothing exists anywhere.” Authentication records, billing records, feedback, founding-firm submissions, and usage metadata are separate product functions with their own storage needs. POOF is specifically about the handling of contract content in the Focus analysis path.
THE TECHNICAL SHORT VERSIONContract content is processed transiently. Deterministic proof is computed. Raw contract text is not retained as the analysis record. A keyed non-reversible fingerprint and usage metadata are retained so the system can enforce allowances and recognize exact reruns.
WHAT COMES NEXT
Persistence should be something you choose.
The planned direction is user-controlled storage: connect a database or system you control, then choose what results should be sent there. Long-term storage becomes an explicit feature, not an invisible side effect of running the analysis.