This system treats every document like a working program — so "finished"
becomes something you can measure, not just feel. You drop in a document;
it gets read, checked for gaps, polished, and tracked all the way to done.
Drop in a document · the system finds what's missing · you fill the gaps ·
it polishes the writing · "complete" becomes a number, not an opinion.
The core idea
In code
Every function has a signature. The compiler verifies that callers
use it correctly. Change a function, the compiler shows you what
breaks. Tests pass or they don't.
In prose
Every sentence is graded and labelled. A check confirms that every
word has a known meaning and every claim connects to the others.
Change a sentence and you see what depends on it. The completeness
check passes or it doesn't. (Under the hood: each
sentence gets a truth tier + CU- barcode, and the audit
scores five dimensions — coverage, bonding, connectedness, sentence
coverage, chain of custody.)
What happens to a document
When you add a document to a project (drag-drop a file, or Import folder), here's the chain that runs:
1️⃣
Store it · the document gets an address
The file is saved and its text pulled out, then given a permanent ID. From here on every other feature — the gap check, the polish, citations, edits — refers to the document by that ID, so nothing gets confused or lost. That ID is a DOC- barcode; every surface addresses the document by it.
The system reads the document sentence by sentence and grades how solid each one is — from settled fact down to unsupported claim — recording why, and how confident it is. Headings, lists, and claims are each handled for what they are. This is the 51-stage pipeline; each sentence becomes a CU- with a truth tier (T0–T12), reasoning, confidence, and links to its word definitions.
"Bank-run material is the bulk feedstock" → CU-7A8F31… · tier T4 (sourced empirical) · 0.91 confidence
↓
3️⃣
Check it · score how complete it is
The document is scored on a few honest measurements: does every word have a known meaning, is every word actually used in a graded sentence, does the whole thing hang together, and can every claim be traced back to its source. When they all pass, the document is provably complete — not "looks done," but measured done. The five dimensions: coverage, bonding, connectedness, sentence coverage, and chain of custody (doc → CU → word → definition resolves all the way down).
The check lists everything the system doesn't yet understand. It sorts each one (an abbreviation? a name? a typo?), borrows context from your other documents, handles the easy ones itself, and asks you only about the genuinely ambiguous ones. Define something once — BBV = Barrett, Bonacic & Van Weele — and every document in every project knows it from then on.
↓
5️⃣
Polish it · improve the writing
The system refines the document to the standard you need — a quick working draft, a filing-ready version, or something a regulator would accept. It checks for statements that contradict your other documents, flags numbers that need a citation, and runs a deep editorial pass (craft, argument, what's missing, what to cut, tone, and more). Every suggestion comes to you as a proposal — nothing that changes meaning is applied without your say-so. This is the perfect-document chain: target-band polish, semantic check, anchor scan, and the 9-lens prose review.
↓
6️⃣
Track it · watch it reach done
Each document moves through clear stages — stored → checked → filled in → polished → ready — shown right on its filing record, so you can see at a glance what's done and what's left.
What you can do once a document is ready
Re-check it for gaps at any time
Run the full polish end-to-end, or step through it one pass at a time
Keep polishing until it reaches the standard you set
Get a deep editorial review with concrete, specific suggestions
Merge several documents together, section by section
See before/after edit proposals and approve only the ones you want
Attach a source to any number or claim
Fact-check it against your other documents
The underlying commands
audit_doc_graph
Re-check completeness · 5-dimension report
perfect_document
Full polish chain end-to-end · one envelope
perfect_step
Walk through polish one pass at a time
auto_polish
Iterate polish until target band reached
prose_review
9-lens editorial pass with concrete findings
smart_merge_docs
Merge 2-5 docs section by section
propose_rewrites
Before/after diff proposals · operator-gated
cite_claim
Anchor a quantitative claim to a source
semantic_check
Fact-check against sibling docs
apply_rewrites
Land approved edits · operator selects IDs
Why you can trust it
Run it twice on the same document and you get the same result — the same grades, the same completeness score, the same report. It's repeatable, not a fresh opinion each time. And when you change a single sentence, you're shown exactly what that affects. Nothing changes in the dark. Technically: the same words produce the same DOC- and CU- barcodes, the same tier assignments, the same audit, and the same closure score on every run.
Four ways to use it
1 · Drop a file→ Projectsopen a project, drag a file in and watch it get read, live
2 · Just asktype plain requests like "polish this document" or "check project 3 for gaps" into any chat bar
You drop in a document. The system reads it closely, scores how complete
it is, asks you to clarify what it doesn't know, polishes the writing, and
tracks the whole thing to done — the same way a compiler builds a program.
When it says "ready," that's a measurement, not an opinion.