Builder
Generate a deterministic recursive paper packet.
Turn a topic, archive, or manuscript into a bounded paper packet with artifact classes, manuscript scans, Henry reviewer pressure, tests, and controls already in place.
Scriptorium
A paper builder app governed by the deterministic recursive method.
Scriptorium turns a topic, archive, or governance problem into a bounded writing packet. It starts from artifact classes, evidence hierarchy, recursive tests, and interface-bound controls before any polished prose is allowed to harden into authority.
Public boundary
Live now
A deterministic browser-side builder that generates recursive analysis packets, controls, and disclosure language from stable method rules.
Lineage
The deeper local execution layer is being adapted from an MIT-licensed AutoResearchClaw base, then reworked into Martin's own Scriptorium framing.
Claim boundary
The public site does not claim autonomous publication-ready truth. It exposes a bounded method surface and keeps heavier local-first automation explicitly under development.
Scriptorium surfaces
Use the app through bounded public surfaces.
The web surface stays clear about what it does today, what method governs it, and where the public project record sits.
Method
Work from the recursive method first.
Scriptorium is governed by Martin Lepage’s deterministic recursive method: artifact hierarchy, bounded claims, interruption points, and interface-bound controls.
Project
Open the public project record.
Return to the public-facing project entry that situates Scriptorium alongside the rest of the local-first app line.
Outputs
See what the live surface produces.
The web surface now ingests long-form manuscript text or `.docx` files and generates recursive analysis packets, quote and reference scans, Henry reviewer sections, disclosure language, and reviewer-pressure scaffolds.
How To Use It
Simple steps for using the builder on the website.
The public app is meant to be straightforward: describe the packet, choose the right method frame, build the result, then copy the markdown into your working environment.
1. Name what you are working on.
Start with the packet title or topic field. Use the name of a manuscript, archive, workflow problem, or research question you want the packet to organize.
2. Choose the governing object.
Pick the main kind of problem you are dealing with: a source tree, a recursive workflow, a governance failure, a disclosure problem, or a control design problem.
3. Pick the kind of output you need.
Select whether you want a recursive analysis memo, an evidence hierarchy note, a control register, disclosure language, or a reviewer-pressure memo.
4. Choose the paper approach and manuscript stage.
Tell Scriptorium what kind of paper you are building and how far along it is. The outline, review criteria, and revision priorities will change based on those choices.
5. Add the manuscript or notes.
Paste the manuscript, upload a `.txt`, `.md`, or `.docx` file, and optionally add quotes or a reference list. The app scans what you give it; it does not invent sources.
6. Describe the packet conditions.
Set the archive profile, consequence domain, and recursive pressure so Scriptorium knows what kind of evidence mix and risk level it is working with.
7. Click Build packet.
The app will generate a bounded packet scaffold with a paper outline, claim ladder, quote and reference scan, Henry reviewer sections, controls, disclosure language, and a markdown export.
8. Read, adjust, then copy.
Review the generated packet, make sure the claim boundary is right, then use Copy packet to move the markdown into your notes, manuscript, or working memo.
Field guide
Packet title or topic
Use this for the exact thing you are trying to frame. Good examples are a book chapter, a document packet, a recursive review loop, or a governance memo topic.
Governing object
This tells the app what the packet is mainly about. If you are unsure, choose the problem that most strongly determines the rest of the analysis.
Output mode
This chooses the shape of the result. Use the memo for broad analysis, the hierarchy note for messy evidence, the control register for workflow fixes, and disclosure when AI-use wording matters.
Paper approach
Choose the kind of paper you are actually writing. Scriptorium uses this to shape the section outline and to decide what Henry should attack first.
Manuscript stage
Pick the stage honestly. Early-stage packets get more scaffolding; later-stage packets get harder reviewer pressure and tighter readiness checks.
Consequence domain
This tells Scriptorium where the consequences land most heavily: authorship, auditability, workflow, legitimacy, documentation, release, or review.
Archive profile
Pick the profile that best matches your material. For example, choose source-heavy for direct records, mixed archive for layered packets, draft-heavy for revisions, and control-heavy for governance materials.
Recursive pressure
Use bounded pass when the loop is still contained, active loop when derived packets are already shaping later rounds, and high recursion when governance packets are governing other governance packets.
Builder
Generate the packet before the prose.
Choose the governing object, archive profile, consequence domain, and recursive pressure. Scriptorium then renders a deterministic packet scaffold with method tests, controls, and exportable markdown.
Deterministic paper builder
Build a manuscript packet, then stress-test it before submission.
Scriptorium keeps Martin's deterministic recursive method in front while adding long-form manuscript intake, quote and reference scanning, user-chosen paper approach, and the Henry reviewer stack. The page runs browser-side, supports long drafts, and does not claim that simulation equals actual peer review.
Use the real paper title if you have it. If not, use the working argument or packet name.
TXT, MD, DOCX
No file loaded yet. Older .doc files should be resaved as .docx before upload.
Long drafts are supported. Use Build packet after paste or upload for the full scan.
Paste text or load from file
The builder scans the text you give it. It does not invent citations, quotations, or external review outcomes.
One quote or note per line works best.
Scriptorium scans both this field and any references already inside the manuscript.
Use when outputs, summaries, or governance packets re-enter the loop and start steering later rounds.
A targeted memo for draft comparison, surviving claims, remaining warrant problems, and the next surgical fix.
Best for argument-led papers that clarify a mechanism, concept, or governing distinction rather than presenting new empirical fieldwork.
Use when the draft exists end to end and needs stronger argument control, scope tightening, and reviewer-style pressure testing.
The packet is dominated by revised drafts, comparison files, clean copies, and reviewer-facing materials.
reviewer-pressure, surviving claims, and next surgical fix
Several recursive passes already exist and some derived artifacts are shaping later interpretation. The main risk is method lock: a repeated summary shape becoming the only visible account of the packet.
Scale
The workbench is built for long drafts. A 10,000-word manuscript can be pasted or loaded locally, then exported without a short-summary cap.
Boundary
Henry simulates reviewer pressure. It does not convert the manuscript into an actually peer-reviewed paper on its own.
Method commitments
The method stays visible in the interface.
Scriptorium adapts to the deterministic recursive method by keeping artifact hierarchy, interruption points, and stop rules visible instead of burying them inside a generic assistant flow.
Artifact hierarchy beats fluency.
Polished synthesis does not outrank the source tree it compresses. Scriptorium starts by separating source-bearing, generated, control, and visualization artifacts.
Recursion has to earn another pass.
If the next pass only adds polish, the method stops. Additional recursion is allowed only when it increases explanatory power or clarifies a real control problem.
Every claim needs a mechanism.
The builder keeps the claim, the mechanism, and the consequence domain visibly linked so conclusions do not drift into unsupported certainty.
Controls bind to interfaces.
A useful control names the failure pattern, the workflow interface, the accountable actor, the evidence artifact, and the review trigger.
Interruption stays available.
Scriptorium assumes every serious packet needs a practical interruption point where an editor, operator, or reviewer can reopen the claim before authority hardens.
Human control remains explicit.
AI can support clerical, structural, or epistemic mediation, but it is not treated as an evidentiary authority. Evidence hierarchy and normative judgment stay under human control.
Execution layers
What the live Scriptorium surface actually produces.
The site stays honest about the current layer: deterministic packet generation on the public web surface, with deeper local-first automation treated as a separate execution layer.
Archive map
Separate the packet before drafting.
The builder begins with source-bearing artifacts, generated synthesis layers, control artifacts, and visualizations so the memo knows what each layer can actually support.
Recursive tests
Run the same bounded checks every time.
Source-tree, re-entry, admissibility, method-lock, interruption, and escalation tests stay visible so recursion does not quietly become authority.
Controls
Translate failure into interface-bound controls.
Each generated packet includes controls with owners, triggers, evidence requirements, and review intervals rather than vague calls for oversight.
Outputs
Export writing scaffolds, not fake certainty.
The live site produces deterministic manuscript packets, quote and reference scans, Henry reviewer sections, and disclosure language. It still does not claim that software alone confers actual peer review.
Lineage and boundary
Made our own without hiding its lineage.
The public framing centers Martin’s method, while the technical lineage remains transparent and properly bounded.
Method first, lineage second.
Scriptorium is publicly framed around Martin Lepage’s deterministic recursive method, not around generic “one-click paper” claims.
Adapted from an MIT-licensed base.
The local execution line is being adapted from the MIT-licensed AutoResearchClaw codebase by Aiming Lab, then reworked into Martin’s own Scriptorium framing and control language.
Bounded public claims.
The public site does not claim autonomous publication-ready truth. It presents the builder honestly as a live deterministic packet surface with deeper local-first execution still under development.