Get something useful done.

Start with one page

Download and open

Download Proofpage for your computer. Extract the archive and open the app. On Mac, drag Proofpage.app into Applications. On Windows, keep the extracted support files beside Proofpage.exe. The desktop app includes Python; you do not need to install Python or use a terminal.

The desktop download opens your workspace in a native Tauri window. Keep it open for scheduled collection. Source/CLI installations still use your browser. Your evidence is stored separately from the application in your user folder under Proofpage/data.

Capture your first page

1. Choose Add source.
2. Paste a public page URL. The name is optional.
3. Leave Collect this page now checked and choose Save source.
4. Open Library, select the captured page, and inspect Reader, Original, Rights, Versions, and Proof.

If a site blocks collection, the source card explains the outcome. For pages you can read after signing in, use the browser companion. Do not paste account passwords into Proofpage.

Check an AI answer

Open Check quotes and paste an answer containing quoted passages and source URLs. Preview the quote/source pairs, correct them if necessary, and start the check. Leave collection off to use only saved pages. A wording match is not a factual truth verdict.

Use the library with an assistant

Open Agent access, copy the setup prompt, and paste it into an assistant that supports local MCP tools. The prompt includes your installed executable and workspace paths. After moving the app, recopy it. Assistant setup and training exports.

Upcoming 0.5.1 onboarding

The review build opens with separate choices for web pages, local files, and optional Google Docs. Start with one source; connect an assistant later. The local library needs no account or AI API key. Revisit this screen through Settings → App & updates → Revisit getting started.

Settings groups General, Connections, Evidence integrity, and App & updates, and remembers your last section. Use the arrow keys to switch sections or Command–Comma (Control–Comma on other platforms) to open Settings. Appearance follows your system by default; theme choices are saved in this browser. Model personalization stays in Business context, where you select sources and review what an assistant can retrieve.

For a document, image or PDF, choose Import files, leave Local files · no account setup selected, choose a file, review its preview, and select Import selected. Structured exports (JSON, CSV, ZIP and conversation archives) still need an account-specific import profile. Those profiles are local labels, not logins. Files with the same name under a profile update the saved record while keeping earlier revisions.

In Agent access, choose Claude Desktop, Codex / ChatGPT desktop, Claude Code, or another local client. Copy the matching setup prompt, or download its setup kit. The kit contains a configuration snippet, instructions, and the workflow skill in its matching project folder. Merge configuration rather than replacing other integrations. Test local server checks the helper; ask your assistant to call proofpage_list_sources to verify its own connection. An empty list is OK.

For Google Docs, sign in through your system browser, paste a selected document link, confirm owner permission, and choose Import document. One action selects and syncs it; future refreshes use Sync. Shared sign-in is under Google review and is not yet included in stable 0.5.0 downloads. Google setup status.

Update safely

Close Proofpage and make a private copy of your Proofpage/data folder before updating. Replace the application, not the data folder, then reopen it. Backups include your private receipt-signing key. Keep the older backup until you have checked the updated library.

Need help?

Report a problem with your operating system, Proofpage version, and what happened. Remove private page content, passwords, and tokens before sharing logs. For optional CLI installation and advanced backup commands, see the installation guide.

Check for app updates

Open Settings → App updates → Check for updates. This explicit check contacts GitHub without sending workspace data. When a newer stable release is available, Proofpage offers the download for this computer, or the release page if there is no matching build.

Back up your workspace and quit Proofpage before replacing the app. On Mac, drag the new app into Applications and choose Replace. On Windows/Linux, extract the complete archive into a new app folder. Keep your home-folder Proofpage/data directory: the library lives separately from the application. This is a guided download-and-replace flow, not automatic installation.

Browser companion

Save a page you can read in Chrome straight to your local Proofpage library. Sign in on the website using its own login form or your password manager. Your passwords and session cookies stay in the browser.

Install

Add to Chrome

Companion 0.3.0 is published in the Chrome Web Store. Open the listing in Chrome, choose Add to Chrome, then confirm Add extension. No Developer mode, extracted folder, or manual ZIP installation is needed. Pin Proofpage from Chrome's Extensions menu if you want its button visible in the toolbar.

Keep the Proofpage desktop app open. Use desktop 0.3.0 or later for the published companion's page and original-file features. The app remains separate from the Chrome extension; the extension saves to your computer, not a cloud workspace.

Connect once per app session

1. Open Proofpage → Settings → Connect browser.
2. Open the companion → Connect your desktop app. Enter the app port and pairing code shown in Settings.
3. Choose Connect and allow the requested connection to the local app. The code expires in five minutes and can be used once.

The connection can only import reviewed content. It cannot read, export, or delete your library. Restarting the app or choosing Disconnect browser revokes access. Create a new code to reconnect. Do not share pairing codes or library content in support reports.

Save a page

1. Open the page and click the companion → Preview this page.
2. Review Page text and remove anything private. Include more from this page optionally adds reviewed links, image references with alt text, and table text; each category is off by default and editable.
3. Confirm I can save this content and have removed private information.
4. Click Save to Proofpage. It appears in your library under Browser pages. Saving the same text twice does not create a duplicate; changed text becomes a new revision.

After pairing, Save sends the reviewed capture straight to the app. No file picker or manual import is needed. If the app is closed, choose Download JSON instead, then use Import files in Proofpage.

Optional page sections contain references and table text, not downloaded original images or linked pages. At most 100 links, 50 image references, and 20 tables are previewed. Review resource URLs too: paths can contain personal information.

Save an original image or PDF

For a public web file, open Save an image directly from this page. Preview the page first and choose an image, or paste a public image/PDF URL. Confirm permission, including embedded metadata, then choose Save web file. The desktop app fetches the original bytes and extracts text locally. You do not need to download the file to your Downloads folder first.

Public URL collection respects robots policies, public-network restrictions, rate limits, and redirects. It does not use your browser login session. For a sign-in-only file, download it yourself first, then use Save an image or PDF file to select, review, and save it. Supported originals are PNG, JPEG, WebP, and PDF, up to 8 MiB. In Library, inspect extracted text, preview images, and download unchanged original bytes or a file-plus-hash bundle. See Media and automation for PDF/OCR limits.

Login and CAPTCHA interruptions

When direct collection encounters a login or CAPTCHA, Proofpage creates an attention entry in Timeline. Enable notifications in Timeline to receive browser notifications while the workspace is open. Click an alert to open Timeline, then Open website. Scheduled collection of the source page pauses.

For training work, complete the challenge yourself and save the resulting readable page with the companion. For an AI agent, collection results include an attention object explaining the interruption and asking it to obtain your approval for that specific challenge before attempting it in your browser. The agent needs its own browser-control capability; Proofpage does not contain a CAPTCHA solver. Authentication happens on the website, not through a Proofpage password form. Browser imports do not transfer your signed-in session to the direct collector or automatically resume a blocked crawl or quote-check job.

Evidence and privacy

Page captures are user-supplied browser text, possibly edited, not raw HTTP responses. No web-capture receipt is issued. The source URL and user-reported save time are retained. Hidden elements, form fields, scripts, cookies, and iframe contents are excluded. URL query strings and fragments are removed from the page preview, which can make URLs less specific. Visible text and selected files can still contain private information: review before saving. Original files retain embedded metadata.

Imported text is searchable by assistants. Automatic URL-based Claim Check and WACZ export use direct captures, not browser-text imports. Rights review still applies before dataset export.

The companion runs only when clicked. It sends reviewed content only to the paired app on 127.0.0.1, not to Proofpage servers. See the companion privacy policy.

Troubleshooting

If a code fails, create a fresh code in Settings. If Save cannot reach the app, check the port and reconnect after restarting Proofpage. Browser internal pages, the Chrome Web Store itself, and other protected tabs may be unreadable. Finish loading the page before previewing. Pages over 500,000 text characters must be split.

The local companion source is 0.3.1 and contains a newer UI. The published store version is 0.3.0. Loading source with Developer mode is optional development work, not the normal installation flow; do not expect unpublished source changes in the store release.

Images, PDFs, and automatic collection

Proofpage 0.3 saves original PNG, JPEG, WebP, and PDF files and makes their text searchable. The desktop download includes the extraction engines and OCR models: no Python installation, terminal, model account, or cloud upload is needed.

Save a file

Choose Import files, select a file, review the preview, and import it. Open its Library card to read extracted text, preview an image, download the unchanged original, or download a bundle with its SHA-256, extracted text, and extraction details.

PDFs with selectable text use PDFium. Pages without selectable text are rendered locally and passed through RapidOCR. Images use RapidOCR. Every extracted page records its method and page number. Extraction is machine-generated and needs checking, especially handwriting, small text, complex layouts, and unusual languages. A successful extraction is not a claim of perfect transcription. Mixed pages with selectable text use that text layer; diagrams on those pages are not separately OCRed.

Originals remain available when extraction fails, a PDF needs a password, or an optional engine is missing. Existing captures are not silently rewritten: reimport an older file to add an extracted revision. Text and extraction metadata are linked to the original SHA-256.

Save directly from a website

In the 0.3 companion, choose Preview this page, open Save an image directly from this page, choose an image, confirm permission, and click Save web file. You can also paste a public image or PDF URL there. Nothing needs to be downloaded to your Downloads folder first. Pair with the running app once in Settings → Connect browser.

Alternatively, paste an image or PDF URL in the app's Add source dialog and collect it. Public URL collection observes robots.txt, public-network restrictions, rate limits, and redirects. It does not send browser cookies or passwords. Signed/query-dependent image URLs may require pasting the complete public URL; the page preview intentionally strips query strings. Do not paste secrets. Private/session-only files can still be imported from a user-supplied file.

The Chrome Web Store companion is now published as 0.3.0 and includes these file controls. Install it with Add to Chrome; Developer mode is not needed. The newer 0.3.1 source UI is separate and has not been published to the store.

Automate it

On a source card, click Watch hourly. While the desktop app is running, Proofpage collects that URL every hour, extracts text, preserves changed revisions, and adds changes to Timeline. Click Stop watching to stop. This works for HTML, supported images, and PDFs. It does not crawl every linked asset automatically.

Folder watches also accept PNG, JPEG, WebP, and PDF files, using the existing exact-filename category selection. CLI collect, scheduled sources, crawl jobs, and MCP collection all use the same collector. Keep the app or proofpage serve running; schedules do not run while your computer sleeps or the app is closed.

Limits and installation

• 8 MiB per original; PNG and decoded image limit of 40 megapixels.
• At most 20 PDF pages and 500,000 extracted characters per file. The result says partial when these limits truncate it.
• OCR images are scaled to at most 2,400 pixels per side. Animated images are not supported as complete animations.
• Each extraction runs in a separate process with a 90-second timeout. One extraction runs at a time. Damaged files cannot indefinitely block collection, but file parsing is not a malware scanner or an OS security sandbox.
• OCR inference uses bundled local models. It does not call an AI provider or download a model at runtime.
• Source installs keep their lightweight default. Install pip install '.[media]' for PDF/OCR support. Desktop builds include it.

Engines: PDFium through pypdfium2, RapidOCR, and ONNX Runtime. Their licenses and bundled notices ship with the packaged dependencies.

Claim Check

Open Check quotes, paste an answer containing quoted passages and URLs, then choose Review quotes and sources. Correct the suggested citation URLs before starting. Preview never fetches pages.

Leave collection unchecked to search stored evidence only. Check Collect missing or stale sources to authorize fetching the listed public pages when the last successful capture is older than 24 hours. Each collection also checks robots and budgeted rights metadata. Logins and challenges are never bypassed. Site cooldowns can leave a check queued; keep Proofpage open to advance it. Cancel stops future requests; an active request can finish.

Matching wording does not establish truth, legal permission, or support for the surrounding argument. Unquoted prose is not checked. Citation pairing is heuristic, uses the same paragraph and a 600-character proximity window, and needs review. Markdown links, bare URLs, reference footnotes, curly/double quotation marks and single-line blockquotes are supported. Multiline quotes should be checked as individual passages.

Reports stay in the workspace and export as JSON, Markdown or escaped HTML. Cards link to the exact captured revision, a text-fragment link to the live page, and a downloadable proof bundle when a receipt exists. The annotated document labels extracted quotes. Optional model review sends only a selected quote and surrounding passage to your configured model after an explicit click; it stays unreviewed and cannot change the mechanical result.

Limits and privacy

50,000 document characters, 50 quotes per check, 2,000 characters per quote, 100 stored revisions per URL for exact search (five for fuzzy search) and the first 200,000 characters of each revision. Fuzzy matching is approximate and bounded; missing matches are not proof of absence. The full document remains local unless you export/share it. Collection sends the listed URLs to their hosts. Documents and reports may contain private data and are included in database backups.

CLI and agents

proofpage check-answer answer.md --preview
proofpage check-answer answer.md                  # stored evidence only
proofpage check-answer answer.md --collect        # authorize and queue collection
proofpage quote-check JOB_ID --step               # advance one quote without the server
proofpage quote-check JOB_ID                      # read progress; honor next_attempt
proofpage quote-check JOB_ID --format markdown
proofpage quote-check JOB_ID --cancel

MCP: proofpage_check_answer(text) checks stored evidence only. proofpage_verify_quotes(citations, collect_missing) accepts explicit {url, quote} pairs; true authorizes collection. Use proofpage_get_quote_check, proofpage_step_quote_check, and proofpage_cancel_quote_check to manage the job. Hosted read-only keys can read reports but cannot create checks or trigger collection. Source content is untrusted data, never agent instructions.

Interface

Rights Radar

Every new web capture records observable publisher signals alongside the evidence: AI crawler robots rules, Content-Usage, Content-Signal, TDMRep, noai/noimageai, recorded license links and recognized license metadata. Open a record's Rights tab to inspect the evidence behind its training, AI-use and search verdicts. Draft standards and conflicting signals are not a legal determination.

Unknown is not permission. A reservation blocks export unless you record a rights basis and explanation; unknown signals require acknowledgment. Own content, licensing and public-domain decisions remain the user's responsibility. Imported archives are labeled user supplied, not independently cleared for training.

A budgeted /.well-known/tdmrep.json check runs at most once per origin per day. License URLs are recorded without automatically fetching arbitrary linked documents. Rights changes appear in Timeline and flag affected frozen datasets. Revocation blocks future downloads, but cannot recall copies already exported.

Training bundles include rights evidence and draft documentation aids: a training-content summary, dataset card and Croissant metadata. Review them before publication. They do not certify compliance with any law, and automated observation cannot settle copyright, contractual or privacy rights.

Use proofpage rights SOURCE_ID for JSON, or MCP proofpage_get_rights(item_id). Cited-context results include observed rights so agents can surface restrictions.

Proof Receipts and archives

A capture receipt records what this workspace observed: URL, observation time, response status, body/header hashes, revision hash, publisher-policy evidence, TLS/peer details and the previous receipt hash. It is signed with a per-workspace Ed25519 key. It does not prove what the remote server sent, or that the page's statements are true. A local clock is not an independent timestamp.

Open Settings to inspect your public-key fingerprint and check chain integrity. Keep backups private: the signing key is stored in the workspace database and travels with backups. Anyone holding that key can sign as your workspace. The stdlib signing fallback is not constant-time; optional cryptography is used when installed.

Signatures and chain links detect altered receipts and missing intermediate links. A trusted saved chain head or external anchor is needed to detect truncation of the tail. A verifier must also establish whether it trusts the included public key; a self-contained bundle alone cannot establish the signer's real-world identity.

Offline proof bundles

Open a record → Proof → Download proof bundle. A per-revision ZIP includes receipts, original body and headers, available rights/policy evidence, anchor proofs and verify_proof.py. With Python 3 installed, extract and run:

python3 verify_proof.py
# Or from a Proofpage Python installation:
proofpage verify proof-bundle.zip
proofpage receipts

No extra Python packages are required for bundle verification. Independently verify receipt signatures with OpenSSL using the instructions inside the bundle. Tampered files fail verification. Old captures without receipts are not backfilled with invented historical signing times.

Optional timestamp anchoring

Off by default. Configure a trusted RFC 3161 timestamp authority and/or OpenTimestamps calendar in Settings. Only a digest of the Merkle root is submitted, not URLs, content or receipts. The service sees your network connection. Anchoring operates in local mode only. A timestamp token needs independent trust/certificate verification; a pending OpenTimestamps submission is not a confirmed Bitcoin timestamp. Upgrade and verify it with the external ots client. Restoring a backup pauses anchoring and collection.

WACZ

Use a source card's WACZ export or proofpage export-wacz SOURCE_ID --output site.wacz. It includes WARC records, indexes, page metadata and receipt sidecars. Assets absent from capture cannot be replayed; this is not a full browser session recording. Reconstructed legacy records are labeled. Ed25519 sidecars are not WACZ-Auth signatures. ReplayWeb.page 2.5.3 replay was verified for a live example.com capture. Verification record.

Train from evidence; give existing models evidence tools

Training workflow

1. Collect a public page, run a bounded crawl, or import a supplied archive.
2. Open evidence and choose Create training example. For a conversation with explicit parent links, choose a particular assistant branch; sibling branches and tool outputs are not flattened into the example.
3. Choose a format: supervised messages, preferred/rejected response pairs, prompt/completion corrections, observed tool traces, or evaluation questions. Supply an exact source quote. Preference pairs require a rationale. Human-message examples require the actual participant and explicit context/role approval.
4. Inspect the draft, full evidence, and screening findings in Training. Confirm permission and correctness, then approve. Model output and imported branches are never automatically approved. Editing creates another draft linked to the prior example.
5. Select approved examples of one format and freeze a dataset. Download its ZIP bundle. It includes trainer payloads, source citations/hashes, a manifest, grouped train/validation/test partitions, and validate.py.
6. Unzip and run python validate.py before using the data. Revoking either source permission or an example's approval blocks future managed exports. Previously downloaded files cannot be recalled.

Payload formats:

SFT and preference shapes follow the primary TRL dataset formats, SFT trainer, and DPO trainer documentation. Load train.jsonl with your trainer's JSON dataset loader and its selected model/tokenizer. Proofpage prepares data; it does not provision GPUs, download a training model, or launch paid training jobs.

Exact payload duplicates are removed. Source groups and near duplicates (0.85 Jaccard similarity of word five-grams) remain together. Assignment is deterministic within the dataset; at least one group is allocated to train unless the format is evaluation. Small bundles can have empty validation/test partitions. Splits are not a global registry: across independently frozen datasets, check source overlap yourself and keep evaluation sources out of training. Heuristic screening catches common credentials, emails, phone numbers, and instruction-like text; it is not comprehensive anonymization or a factual verifier. The original evidence stays unchanged when a draft is redacted.

Existing models through MCP

Configure your MCP-capable assistant with Agent access or the command in README. Tools support source inspection, collection, cited retrieval, freshness checks, durable bounded crawls, extraction submissions, and training drafts. No approval/export tool is exposed. Configure source URLs in Proofpage or authorize your agent to add them with proofpage_add_source.

Typical sequence:

1. proofpage_list_sources
2. proofpage_ensure_fresh with source_id and max_age_seconds
3. proofpage_get_context with query
4. Answer with the returned citation IDs, or submit a grounded draft through proofpage_draft_example.

For multiple pages: proofpage_start_crawl, proofpage_step_crawl, proofpage_get_crawl, and optionally proofpage_cancel_crawl. The web server advances jobs automatically; a standalone stdio client must call step. Respect next_attempt; do not loop through cooldowns. Collection stays on the starting origin and directory, up to 20 pages/depth 3. HTML links (including pagination links), sitemap/XML/RSS links are discovered. A feed is a discovery source, not inferred article content. Jobs survive restart; individual failures remain visible. Restore cancels pending crawls. Cancellation stops future requests; an in-flight request may finish.

python examples/agent_client.py --home .proofpage "your search" demonstrates a real subprocess handshake and cited context request. Recorded successful collection/context/freshness calls can become observed-trace drafts. Internal reasoning is never inferred or fabricated.

Use a local or hosted model in the workbench

Before starting the server:

export PROOFPAGE_MODEL_URL=http://127.0.0.1:11434/v1
export PROOFPAGE_MODEL_NAME=your-installed-model
# Hosted endpoints can additionally use PROOFPAGE_MODEL_KEY.
python3 -m proofpage --home .proofpage serve

Use an OpenAI-compatible /v1 base URL supporting chat completions and JSON output. Ollama documents OpenAI compatibility. Proofpage does not install or pull an LLM. Remote endpoints require HTTPS; redirects are refused. Credentials stay in the server environment and are not shown in the UI.

Draft with my model sends up to 20,000 characters of selected evidence only after the explicit send action. Detected credentials block transmission. Review personal data before sending to a hosted provider. New extraction recipe defines fields; Extract with my model requires exact source quotes for non-null values. Missing fields are null. An exact quote does not prove the model interpreted it correctly. Results remain unreviewed.

Optional offline JavaScript rendering

python3 -m venv .venv
.venv/bin/python -m pip install -e '.[render]'
.venv/bin/python -m playwright install chromium
.venv/bin/python -m proofpage --home .proofpage serve

Enable rendering in a crawl. Chromium executes captured inline JavaScript with external resources, network calls, service workers, and WebSockets blocked. Original HTML is retained in provenance. Pages requiring external scripts or API data remain incomplete; this is deliberately not a general authenticated browser crawler. Each capture records blocked-request coverage. Missing Chromium produces a failed run, never a successful capture.

Connect by copying a prompt

In the local workspace, open Agent access → Copy setup prompt, then paste it into an MCP-capable AI assistant. The prompt includes the actual executable and workspace paths. Copy MCP configuration provides the raw JSON instead. If clipboard access is denied, Proofpage displays selectable text for manual copying.

The upcoming 0.5.1 interface starts by asking which assistant you use. It provides Codex / ChatGPT desktop TOML or Claude JSON, matching instructions, and a downloadable setup kit with the workflow skill. The web-chat option explains how to export reviewed context instead of showing an unusable local command. Test local server checks initialization, all advertised tools, source listing, and business-profile listing without collecting anything. Only a successful tool call in your assistant verifies that client's connection.

Configuration formats follow the official OpenAI MCP guide and Claude Code MCP guide.

Desktop downloads include a separate console MCP helper, so the assistant does not need a system Python installation. Keep the app's support files together and recopy settings after moving the app. The assistant must support local stdio MCP and be permitted to configure integrations; a prompt cannot add support to clients that lack it. It should preserve existing configuration and verify the connection with proofpage_list_sources. A normal web-chat model may only be able to explain the setup.

The prompt contains local filesystem paths, but no API keys or session token. Hosted users should create scoped keys in Account and configure them through the client's secure credential settings, never paste secrets into a prompt.

Evidence tools

Rights, history and receipts: proofpage_get_rights, proofpage_diff_revisions, proofpage_list_changes_since, proofpage_get_receipt.

Quote checks: proofpage_check_answer, proofpage_verify_quotes, proofpage_get_quote_check, proofpage_step_quote_check, proofpage_cancel_quote_check. Schemas and consent. Mechanical matches and model-written reviews never approve training data.

Collection and training workflows

Agent access includes copyable collection, research and training prompts. An authorized agent can now add a public page, image or PDF with proofpage_add_source(name, url), collect it, and configure recurring collection with proofpage_schedule_source(source_id, interval_seconds). Use 0 to pause, or 300–31536000 seconds. Source registration validates the public destination but does not collect content. Duplicate URLs reuse the existing source.

Keep the Proofpage app/server running for scheduled work. A local stdio MCP process alone does not run the scheduler. Multi-page jobs can be advanced with the existing step-crawl tool, respecting next_attempt. Rights signals, robots rules, shared site budgets and access restrictions still apply.

For custom-model work, choose SFT conversations, preference pairs, corrections or evaluation examples. The agent can propose drafts tied to exact source quotes, including extracted PDF/OCR text. Review extraction accuracy, permission and privacy findings, approve in Training, then freeze and export the trainer bundle. Proofpage prepares datasets; it does not train model weights. Original media remains available as evidence; native image/audio/video training formats are not implemented.

Client compatibility

Local stdio configuration is for clients supporting local MCP, such as Claude Desktop and coding assistants. It cannot be pasted as a remote URL into ChatGPT web or Claude web. ChatGPT requires a compatible remote MCP connection; Proofpage's hosted bridge is not yet a ChatGPT-ready OAuth/Streamable HTTP connector. Do not expose the local app or credentials to work around this. Export evidence for manual upload when a local MCP client is unavailable.

References checked October 18, 2026: Claude local MCP setup, ChatGPT MCP requirements.

Setup verification and reusable skill

In Agent access, choose Test MCP connection. Proofpage launches its actual stdio helper in an unrelated working directory, initializes MCP, lists tools and reads this workspace's source list. It collects no pages. Missing helpers, timeouts and invalid responses are reported as failures. This checks the server installation, not whether Claude or another client has loaded its configuration; confirm that separately with proofpage_list_sources in the assistant.

Choose Download SKILL.md or Copy skill for collection, schedules, cited research and training-draft instructions. The packaged source is proofpage/skills/proofpage/SKILL.md. Install it with your assistant's skill mechanism. For project-local Codex use .agents/skills/proofpage/SKILL.md; for Claude Code use .claude/skills/proofpage/SKILL.md. The skill does not install MCP, grant access or start a scheduler.

Sources now offers Set schedule / Edit schedule, with 15-minute, hourly, six-hour and daily choices plus pause. The first scheduled check starts after that interval; use Collect for an immediate capture. Keep the app/server open, and inspect Activity and Timeline for actual results and delays.

Personal preferences and personal training data

Settings → Appearance offers Follow system, Light and Dark. The choice is saved in this browser, follows system changes when selected, and syncs across tabs on the same origin. The library also remembers grid/list layout. Browser preferences are not synced between devices or different app ports; clearing browser storage resets them. When browser storage is unavailable, the theme applies for this visit and the app explains that it could not save it.

For personal-model datasets, create separate import profiles for each provider/account. Human-message examples require the actual sender as the target participant and explicit confirmation of context and role mapping. API clients must supply JSON booleans true, not strings or numbers, for context_confirmed and roles_approved. These decisions persist with the example; permission/privacy review and approval are still required before freezing a dataset. Appearance preferences do not personalize model weights, and Proofpage exports training data rather than running fine-tuning itself.

Portable business context

Available in 0.5.0. MIT licensed, local-first, no account, paid service or model API key required. This feature prepares user-reviewed context; it does not modify ChatGPT/Claude account memory or train model weights.

Setup

1. Import selected files using Import files. For Google Docs, use the optional selected-document sync connector, or export to text/PDF and import manually.
2. Open Business context and create a profile.
3. Select evidence and classify it as Our business, Customer material, Reference material, or Writing example. In the upcoming 0.5.1 interface, **Find saved evidence** searches independently of Library and shows up to 100 recent matches. Stable 0.5.0 uses the Library's current search results.
4. Suggest passages. These are deterministic verbatim passages, not AI-generated summaries or inferred preferences. Review conflicting statements yourself.
5. Edit, approve or exclude each suggestion. Approval requires permission and review acknowledgments. Detected credential-like content blocks approval.
6. Download the ZIP and inspect it before sharing with an assistant provider.

The ZIP contains BUSINESS.md, INSTRUCTIONS.md, context.json and README.md. Only approved text and its supporting quotations are included. Original files and unrelated profile drafts are excluded. Customer/reference content is labeled separately; it must not be interpreted as your business's products or policies. Writing examples remain examples, not inferred style instructions.

For bookmarks, export HTML from your browser, preview it in Business context, and explicitly select entries. Only public-style HTTP(S) URLs without embedded credentials are accepted; javascript/file URLs are ignored. No page is fetched. Bookmark records cannot be attached as business evidence. Add a desired URL in Sources, collect it explicitly, then attach its captured revision.

If a selected source changes, approved context based on the old revision blocks export/retrieval. Exclude the old passages, attach the current revision and review new suggestions. Changing a source's role resets its approvals. A context pack already uploaded elsewhere cannot be remotely revoked by Proofpage.

The upcoming 0.5.1 interface remembers the chosen profile in this browser and separates pending, approved, and changed-source passages. Its progress strip shows the next step, and download becomes available after at least one current passage is approved. Drafts and excluded passages stay out of exports and MCP retrieval. These controls do not replace the server's approval and stale-source checks.

Developer interfaces

from proofpage.sdk import Proofpage
p = Proofpage(home='./workspace')
profile = p.create_business('Acme')
p.attach_business_source(profile['id'], 'REVISION_ID', 'business')
draft = p.draft_business(profile['id'])
# Present draft['facts'] to the person reviewing them before calling approval.
fact = draft['facts'][0]
p.review_business_fact(fact['id'], fact['text'], 'approved',
                       permission=True, acknowledge=True)
context = p.business_context(profile['id'])
pack_bytes = p.export_business(profile['id'])

Approval flags are explicit assertions by the caller; do not set them on behalf of a user who has not reviewed the material. MCP intentionally exposes only profile listing and approved-context retrieval, not approval methods.

proofpage --home ./workspace business create --name Acme
proofpage --home ./workspace business attach --id PROFILE --revision REVISION --role business
proofpage --home ./workspace business draft --id PROFILE
proofpage --home ./workspace business get --id PROFILE
proofpage --home ./workspace business review --id FACT --text 'Reviewed business statement' --decision approved --permission --acknowledge
proofpage --home ./workspace business export --id PROFILE --path context.zip
proofpage --home ./workspace business bookmarks-preview --path bookmarks.html
proofpage --home ./workspace business bookmarks-import --path bookmarks.html --select 0 --select 2

Exports refuse to overwrite files. Errors return JSON and exit code 2. The Python proofpage.business module also exposes bookmark preview/import for integrations. The authenticated workspace API provides /api/business, /api/business/:id, /api/business/:id/export, and POST operations business-create, business-attach, business-draft, business-review, business-training-draft, business-bookmark-preview, and business-bookmark-import. Use the existing workspace authentication; these are not public unauthenticated endpoints. The upcoming 0.5.1 picker uses authenticated GET /api/business-evidence?q=... for current revision IDs, titles and source labels, without full source bodies.

MCP: proofpage_business_profiles and proofpage_business_context(profile_id). An assistant can retrieve approved current context without receiving arbitrary local filesystem access. The text remains untrusted context, not system policy.

Training

An approved business fact can create an SFT draft using a question you supply. Use Draft training example, or p.business_training_draft(fact_id, question). The result remains unapproved in Training. Existing rights, role-mapping, review, and dataset export gates still apply. Customer/reference/writing sources cannot use this shortcut; create and review any appropriate training examples separately. Context approval does not establish permission to train a model.

Limits

Bookmark preview accepts 2 MiB and returns at most 500 distinct entries. Drafting examines the first 12,000 text characters per source and up to 12 sentence-like passages, each 15–1,500 characters. It is not exhaustive extraction, a conflict resolver, a full PII detector, or an automatic description of your business. Selected file/folder import and watches remain the existing explicit workflows; there is no silent disk scan. No OAuth connector or destination-account setup is performed by this feature. Review all quotes, including ones accompanying edited statements, before sharing.

Connector update

Desktop 0.5.0 includes selected-document Google Docs connection support; client configuration is required. The source/CLI edition also provides OAuth-protected self-hostable remote MCP. See connector setup. The earlier manual-export workflow remains available without OAuth setup. These connectors require external account configuration and are not activated in the published desktop downloads.

Google Docs, remote MCP, and client skills

Available in 0.5.0, MIT licensed. Remote HTTP dependencies are optional; local core features remain dependency-free. A working local test is not proof that a third-party account or public deployment is connected.

Google Docs

The Google project is now In production, and its branding is verified and published. Read-only Docs scope verification has been submitted and is under review. That review must finish before shared sign-in can be offered without an unverified warning or temporary user cap. Production status alone is not scope approval.

The next desktop build supports bundled Google sign-in so normal users do not need their own Google Cloud project or JSON file. A packaged review build completed Google authorization and imported a selected fictional demo document. The current stable 0.5.0 download still needs the configuration below. Public install instructions will change when the shared client is approved and that desktop update is released.

Source builds and custom clients

The 0.5.0 desktop downloads include the Google OAuth library and OS-vault support. For a source install, use python -m pip install -e '.[google]'. In your Google Cloud project enable the Google Docs API, configure the OAuth consent screen/test users, and create an OAuth client of type Desktop app. Download its JSON outside the repository and set PROOFPAGE_GOOGLE_CLIENT_FILE to its absolute path when starting Proofpage. Alternatively, place it at ~/.config/proofpage/google-oauth.json for automatic discovery. Never commit this file or paste credentials into prompts. Public distribution may require Google's verification.

In Business context, click Connect Google Docs. Complete authorization in the system browser. The connector uses authorization code + PKCE with a loopback callback, via Google's OAuth library. The requested documents.readonly scope can read the account's Docs; the application only fetches IDs you explicitly select. This is not per-file OAuth permission or a Drive-wide crawler.

Paste a document URL, choose Manual/Hourly/Six-hourly/Daily, save the selection, confirm owner permission for local personal-context snapshots, and click Sync. The content appears in the library for profile attachment and review. Tables and nested tabs are read. Extracted text excludes images, comments, headers/footers and suggested edits; original returned API JSON is preserved. Up to 8 MiB is accepted. Failed/empty responses preserve previous evidence. Automatic schedules require the app/server to remain open. Changed revisions invalidate approved business context rather than silently altering it.

In the upcoming 0.5.1 interface, Import document combines selection and the first sync. It keeps the entered link when importing fails and shows a retry or reconnect action. A failed optional Google connection does not prevent using other business sources. Missing/invalid client setup does not request access to the OS credential vault.

Google API snapshots are for personal context. In the 0.5.1 review build, dataset approval, corpus freezing, training examples, and existing dataset downloads reject them. Training-draft model calls are blocked before transmitting the source text. Business context keeps its separate passage review and export workflow. Google Workspace data cannot be used to train shared or general-purpose models. Only retain snapshots with express owner permission. See Google Workspace data policy and Google API content terms.

Tokens are stored only in an OS vault: macOS Keychain, Windows Credential Locker, or Linux Secret Service. The connector fails closed when those backends are unavailable; no plaintext fallback. Credentials are scoped to the workspace path and are excluded from database backups. Moving a workspace requires reconnecting. Disconnect removes local credentials and pauses schedules; previously imported evidence stays. Revoke the account grant in Google permissions separately.

CLI equivalents:

proofpage --home ./workspace google-docs status
proofpage --home ./workspace google-docs connect
proofpage --home ./workspace google-docs select --document DOC_ID --interval 3600 --owner-permission
proofpage --home ./workspace google-docs sync --document DOC_ID
proofpage --home ./workspace google-docs disconnect

Google auth is local-only. Hosted workspace routes cannot trigger desktop consent or access the host's OS vault. A custom client selected through the environment or the existing home-folder configuration takes precedence over bundled metadata. PROOFPAGE_CONFIG_DIRECTORY can select a separate configuration directory for a portable profile; the default remains ~/.config/proofpage. User authorization is still tied to the workspace path in the OS vault. Moving the OAuth project to Production does not retrofit a client into existing 0.5.0 downloads. Shared sign-in needs the updated desktop build as well as Google's scope approval.

Building official preconfigured downloads

Release maintainers can set PROOFPAGE_DESKTOP_GOOGLE_CLIENT_FILE to their Google Desktop app client JSON when running scripts/build_desktop.py. They may also run the following on an extracted CI build, before code signing:

python scripts/configure_desktop_google.py /path/to/Proofpage.app --client-file /private/path/native-client.json

Use the extracted Proofpage directory on Windows/Linux. The helper validates Google endpoints and loopback redirects, rejects web/service-account configs, rejects user tokens/private keys, and copies only native app metadata. It is idempotent for an identical client and refuses replacing a different identity. Never commit the client JSON or place it in source bundles. Native app metadata identifies the app and is recoverable from its distributable; it is not a user's authorization. PKCE protects each authorization exchange, and user tokens stay in the OS vault. Redistributed forks should configure their own Google app.

Finish with signature/notarization and packaged checks using a clean home folder; the report must show google_configuration: bundled. That proves the release is not accidentally relying on the maintainer's home-folder setup file. Review builds do not imply Google's approval, and unverified sign-in is not promoted to stable users.

Remote MCP for web assistants

Install python -m pip install -e '.[mcp-http]'. Configure an OAuth authorization server that supports the intended client's discovery/registration flow, PKCE, and JWT access tokens with the resource URL as audience. Your provider must issue the proofpage:read scope and a stable subject for your account. No authorization provider, public host or client registration is provisioned by this repository. This service is the OAuth resource server, not a login provider. Using a generic OIDC provider without compatible client registration is insufficient for some web assistants.

export PROOFPAGE_MCP_URL=https://mcp.your-domain.example/mcp
export PROOFPAGE_MCP_ISSUER=https://your-issuer.example/
export PROOFPAGE_MCP_JWKS_URL=https://your-issuer.example/.well-known/jwks.json
export PROOFPAGE_MCP_SUBJECT=YOUR_ACCOUNT_SUBJECT
proofpage --home /path/to/dedicated-workspace mcp-http --port 8910

These are deployment identifiers, not tokens. Run an HTTPS reverse proxy in front of 127.0.0.1:8910, preserving the public Host and paths including /.well-known/oauth-protected-resource/mcp. Configure request limits and avoid logging Authorization headers. Do not expose the desktop UI port as a substitute. Use a dedicated workspace containing only material you intend to share.

The official MCP SDK handles Streamable HTTP, initialization, tools, resource metadata, and authentication challenges. Tokens require RS256/ES256 signatures from the configured JWKS, exact issuer, matching resource audience, expiry, proofpage:read, and the exact configured subject. Missing/wrong tokens fail. Only five read tools are exposed: business profile listing, approved business context, bounded evidence search, recorded-context replay, and run listing. No collection, approval, filesystem paths, credential changes or training writes. This is a single-owner workspace server, not a multi-tenant team service.

Add the public URL in a web assistant's supported custom connector flow and complete its OAuth consent. Feature availability and admin restrictions vary by client/account. Verify by listing profiles and retrieving a known approved profile; never report success based on configuration alone. This supplies context to conversations/tools, not automatic account memory or weight personalization.

The existing /agent hosted bridge remains separate and uses Proofpage agent keys; it is not a substitute for this OAuth connector.

Skills that install without clobbering work

In the upcoming desktop build, choose your client in Agent access, then Download setup kit. Codex kits include TOML and .agents/skills/proofpage/SKILL.md; Claude Code kits include JSON and .claude/skills/proofpage/SKILL.md. Claude Desktop and other clients receive generic skill files for their supported installation flow. Follow SETUP.md, merge the configuration snippet, and copy the skill into your selected project. The kit contains local paths; keep it private. It contains no credentials or library content and does not overwrite a live client configuration.

The source-edition CLI also installs the bundled skill directly:

proofpage install-skill --project /path/to/project --client codex
proofpage install-skill --project /path/to/project --client claude

The installer writes .agents/skills/proofpage/SKILL.md or .claude/skills/proofpage/SKILL.md, recognizes an identical existing installation, and refuses to overwrite custom content. A skill provides workflow guidance; it does not establish MCP connectivity. Use Agent access's configuration and Test local server separately (called Test MCP connection in 0.5.0). The shipped skill names only existing tools. Verify your assistant itself by listing its tools and calling proofpage_list_sources; a local helper test does not establish that a particular assistant is connected.

Verification and boundaries

Automated tests exercise the real stdio server through the official MCP client: initialize, discovery, record/replay, approved context, drift and invalid arguments. HTTP tests exercise the official SDK with signed fixture JWTs: missing/expired/ wrong-subject/wrong-audience/wrong-scope tokens, allowed reads, absent write tools, and cross-origin denial. Google fixtures cover multi-tab/table extraction, selection, deduplication, revision drift and failed refresh preservation.

The packaged review build completed real Google account consent and selected fictional-document sync, including retained authorization after restart. Google's public scope approval is still pending. Web-based ChatGPT/Claude remote connectors separately require a public OAuth-protected deployment and consent; local client configuration does not activate one. Fixture-token tests do not verify your authorization provider's registration or a third-party account.

Primary references:

• https://developers.google.com/identity/protocols/oauth2/native-app
• https://developers.google.com/workspace/docs/api/reference/rest/v1/documents/get
• https://github.com/modelcontextprotocol/python-sdk
• https://help.openai.com/en/articles/12584461-developer-mode-and-full-mcp-connectors-in-chatgpt
• https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp

Reproducible evidence for developers

Desktop 0.5.0 includes the saved-input UI and MCP tools. For CLI and SDK use, install this checkout with python -m pip install -e .. Python 3.11+ is required.

Record and replay

from proofpage.sdk import Proofpage

client = Proofpage(home='./evidence-workspace')
captured = client.capture('https://example.com')  # explicit network operation
if captured['collection']['state'] != 'available':
    raise RuntimeError(captured['collection'])
manifest = client.record(captured['revision_ids'], name='research-answer-1')
pin = client.write(manifest, 'inputs.json')  # refuses to overwrite
saved = Proofpage.replay('inputs.json', expected_sha256=pin)  # no workspace/network
text_for_model = saved['records'][0]['text']

Replay supplies the exact recorded text and stored original representations. It is not browser interaction replay or a promise of identical model answers. HTTP originals are labeled exact or reconstructed; supplied revision raw data is explicitly labeled stored_raw_utf8. OCR/extractor metadata is preserved as stored; older records may lack extractor versions. There is no automatic interception of model or browser calls. Record the revisions actually used.

Trace outputs to exact quotations

Pass dependencies to client.record:

revision = captured['revision_ids'][0]
# Offsets are Python Unicode character indices, not UTF-16 offsets.
dependencies = [{
    'output_id': 'answer-1', 'revision_id': revision,
    'start': 0, 'end': 7, 'quote': text_for_model[:7]
}]
manifest = client.record([revision], dependencies=dependencies)
report = client.check(manifest)

Quotes must exactly match a nonempty slice. Compare returns changed/missing records, lexical differences, affected output IDs, and whether each quote still occurs in the current text. It checks the local workspace, not the live web. client.refresh(manifest) explicitly fetches original public targets through normal collection restrictions/budgets, then compares. Blocked/deferred results are reported; old evidence is not silently treated as a successful refresh. A changed source marks an output for review; it does not prove the output false.

CLI and CI

proofpage --home ./evidence-workspace evidence record inputs.json --revision REVISION_ID
proofpage evidence replay inputs.json --sha256 TRUSTED_MANIFEST_SHA256
proofpage --home ./evidence-workspace evidence check inputs.json --sha256 TRUSTED_MANIFEST_SHA256
proofpage --home ./evidence-workspace evidence refresh inputs.json

Use --dependencies dependencies.json when recording. Commands return JSON. Exit codes: 0 successful; 1 drift/missing evidence or unsuccessful refresh; 2 malformed inputs, failed checksum, or file errors. Replay does not create a workspace. Check requires the original workspace (or its backup) for current revision comparison. A fresh workspace reports missing evidence.

The reusable composite action lives at .github/actions/evidence-check:

- uses: actions/checkout@v4
- uses: actions/setup-python@v5
  with:
    python-version: '3.13'
- run: python -m pip install -e .
- uses: ./.github/actions/evidence-check
  with:
    manifest: fixtures/inputs.json
    sha256: YOUR_REVIEWED_MANIFEST_HASH
    # home: restored-workspace  # optional current-revision comparison

This example runs inside a checkout containing Proofpage. External projects should check out a reviewed Proofpage commit separately, install that path, and reference its action directory. Pin the commit; do not install an unrelated same-name registry package. Upload proofpage-evidence-report.json with if: always() if you need drift reports as CI artifacts. Offline-only mode validates integrity; it does not claim freshness. No automatic network refresh. Keep the trusted checksum in reviewed configuration separate from untrusted manifest updates. Hashes establish integrity relative to a trusted pin, not publisher identity. Manifests contain source content and may contain sensitive material; review before committing them to a public repository.

Node and TypeScript

The local SDK is in sdk/typescript (not published to npm):

import { Proofpage } from './sdk/typescript/index.js';
const client = new Proofpage({ python: '/path/to/venv/bin/python', home: './evidence-workspace' });
const saved = await client.record('inputs.json', { revisions: ['REVISION_ID'] });
const replay = await client.replay('inputs.json', { sha256: saved.sha256 });
const report = await client.check('inputs.json');
if (!report.ok) process.exitCode = 1;

This SDK launches the local CLI without a shell and includes TypeScript types, a 30-second default timeout and AbortSignal cancellation. Set timeoutMs higher for explicit refreshes. Drift resolves to a report; malformed inputs reject. The Python engine must be installed. This is not a hosted HTTP SDK, and no automatic retries are performed for mutations.

Current boundaries

Manifests are capped at 64 MiB, include base64 originals, and are not encrypted or signed. Existing separately signed proof bundles remain available. Dependency tracking is explicit, per manifest; dependencies are recorded through explicit SDK/MCP retrieval, not arbitrary model interception. There is no shared team service, PDF-region UI, or new training exporter in this increment. See DEVELOPER_PLAN.md for the roadmap and customer-validation milestones.

Try the regression demo

Run python examples/evidence_regression.py from this checkout after installing it. The offline fixture changes a price, identifies the affected answer, and asserts that replay still supplies the original price. It uses a temporary workspace and leaves your library untouched. This example also runs in CI.

Persistent agent runs and reverse dependencies

Everything here is MIT licensed and runs locally. No subscription or vendor API key is needed. The additive database migration preserves existing workspaces.

client = Proofpage(home='./evidence-workspace')
retrieval = client.record_context('pricing', output_id='answer-42', name='Pricing research')
if retrieval['recording']:
    run_id = retrieval['recording']['run_id']
    pinned = client.replay_context(run_id)
    comparison = client.check_run(run_id)
    client.export_run(run_id, 'answer-42-inputs.json')

The dependency means the excerpt was supplied to an output, not that a model actually used it. Saved runs are immutable. Recording again creates another run, even with the same output ID. client.affected_outputs(item_id) finds recorded output dependencies whose source revisions differ from the current library. Missing records are included. Checks do not perform network requests.

In the app: Agent access → enter a query and an Output ID → Retrieve context. Use Recorded agent inputs → Load saved runs → Replay / Check / Export.

CLI:

proofpage --home ./evidence-workspace evidence-run record-context --query pricing --output-id answer-42
proofpage --home ./evidence-workspace evidence-run list
proofpage --home ./evidence-workspace evidence-run replay RUN_ID
proofpage --home ./evidence-workspace evidence-run check RUN_ID
proofpage --home ./evidence-workspace evidence-run affected ITEM_ID
proofpage --home ./evidence-workspace evidence-run export RUN_ID --output inputs.json

Node exposes recordContext, listRuns, replayRun, checkRun, affectedOutputs, and exportRun. MCP exposes proofpage_record_context, proofpage_replay_context, proofpage_check_evidence_run, proofpage_list_evidence_runs, and proofpage_affected_outputs. MCP returns bounded recorded excerpts; exporting large originals remains an explicit app/CLI/SDK action. No filesystem paths are accepted by these MCP tools.

Bring your own collector

Use client.import_capture(url, text=extracted_text, original=original_bytes, content_type='text/html', collector='your-collector/version') to record output from Playwright, Firecrawl, or your own collector. This method does not call those services or fetch the URL. Supply the bytes your collector actually returned. For Playwright's rendered HTML, encode await page.content() as UTF-8; do not describe it as the original HTTP response. For a provider's Markdown output, use text/markdown and the returned Markdown bytes.

Imports are explicitly caller-supplied, cannot obtain HTTP receipts retroactively, and preserve collector metadata. Capture policies and permissions remain the caller's responsibility. The same revision can feed record, training review, or context retrieval. Each text/original is limited to 8 MiB.

CLI and workflows

CLI

python3 -m proofpage --home .proofpage collect https://example.com
python3 -m proofpage --home .proofpage search documentation
python3 -m proofpage --home .proofpage profile "Personal LinkedIn" --provider LinkedIn --account personal --adapter linkedin
python3 -m proofpage --home .proofpage import export.zip
python3 -m proofpage --home .proofpage import export.zip --select Messages.csv --profile PROFILE_ID

The first import command previews categories; the second imports only selected entries. Use the ID returned by profile for PROFILE_ID. Reuse a profile for successive archives from the same account, even when the ZIP filename changes. Different accounts use different profiles. Stable supplied IDs create revisions when records change; rows without IDs are deduplicated by content and become separate records when changed. Markdown, text, and HTML documents use their category filename as stable identity.

Adapters are tested with synthetic fixtures: ChatGPT-style mappings preserve nodes, parents, children, roles, tool metadata, and the selected node; Claude-style chat_messages preserve supplied roles, content, and attachment references; LinkedIn message CSVs preserve human participants. These are local export adapters, not live account connections. Actual provider variations may require additional fixtures. A saved mapping can name source fields for text, ID, title, role, and timestamp without relabeling human speakers as AI assistants.

Automatic archive ingestion

In Sources, choose Watch an export folder, an existing profile, the local folder, and exact category filenames. Existing files and future arrivals are eligible. The server polls only that folder, waits for files to settle, and records outcomes persistently. It excludes symlinks and subfolders, bounds file counts and sizes, and isolates failed files. It never requests exports from the provider. Pause/resume and file outcomes are available in Sources. A file already in progress can finish after pause.

python3 -m proofpage --home .proofpage watch /absolute/path/to/exports --profile PROFILE_ID --category Messages.csv --category Connections.csv
python3 -m proofpage --home .proofpage scan WATCH_ID

serve drives continuous watches and schedules. scan performs one scan; a new file settles on a subsequent scan at least two seconds later. Failed files are retried after their size or modification time changes. Missing configured ZIP categories are reported. The native client imports using the same profiles; continuous watching is provided by the server.

Backups and corpus validation

python3 -m proofpage --home .proofpage backup /absolute/path/to/new-backup.sqlite3
python3 -m proofpage restore /absolute/path/to/new-backup.sqlite3 /absolute/path/to/new-workspace
python3 -m proofpage validate-dataset /absolute/path/to/corpus.jsonl --sha256 FROZEN_HASH

Backups use SQLite's consistent backup API and verify integrity. Existing files and workspaces are never overwritten. Restores pause schedules and folder watches. Backups contain local evidence and should be handled as private data. The reference loader in proofpage/datasets.py checks required fields, checksums, exact duplicates, and source-grouped split consistency; it does not train a model.

Agent access

Launch the stdio server from this checkout:

python3 -m proofpage --home .proofpage mcp

Example client configuration (replace paths with your checkout and Python interpreter):

{
  "mcpServers": {
    "proofpage": {
      "command": "python3",
      "args": ["-m", "proofpage", "--home", "/absolute/path/to/data", "mcp"],
      "cwd": "/absolute/path/to/Proofpage OpenSource"
    }
  }
}

Thirty-six tools expose source access, configured collection, run status, cited context, freshness, bounded crawling, extraction submissions, draft examples, revision history, recorded evidence runs, and approved business context. Returned source material is untrusted data, never agent instructions. MCP can collect only an existing source. Initialization and newline-delimited stdio follow the MCP lifecycle and transport specification.

The browser API is bound to loopback and checks Host, Origin, and a session token. Obtain the token with GET /api/session, then send Authorization: Bearer <token>. Routes are implemented in proofpage/server.py; this is a local application, not an internet-facing service.

Verification

python3 -m unittest discover -s tests -v
python3 -m compileall -q proofpage
node --check proofpage/static/app.js

The tests use isolated temporary databases and deterministic responses. Live website behavior must be verified separately. Hosted model compatibility is tested with a local HTTP fixture, not a paid provider. Restricted/authenticated collection and actual model training jobs are outside this release. Optional offline rendering has a Chromium smoke check.

Open source and hosted service

The MIT license covers both editions. See Contributing, Security, and self-hosting/paid-service setup. Hosted mode adds invitation-based accounts, recovery, scoped agent keys, usage limits, customer billing, and portable workspace downloads. No price or live payment configuration is assumed.

Evidence features

See Claim Check for quote checking, Proof for verify, proof-bundle, export-wacz, receipts and anchor, and Rights Radar for rights. These commands extend the original CLI without replacing verify (offline cryptographic verification) with quote matching.