Live Product Surface

Stonewall — Legal Document Intelligence Platform

Stonewall is a production-grade legal document intelligence control plane built by a solo litigation attorney. It turns flat files, validated sidecars, AI recall discipline, and static deployment surfaces into a portfolio command dashboard for artifacts, deadlines, workflow readiness, and daily operating visibility.

Open Portal Demo Read Official Brief Open GitBook Edition

Python 3.12+ Flat-File Database Notion Operator Layer Claude Recall Stack GitHub Actions

By The Numbers

Scale without a database server

These counters load from site-data.json so the page deploys as a static artifact while preserving the real operating scale and architecture of the platform.

The underlying corpus remains Git-tracked, grep-queryable, and validation-friendly, which is the central architectural thesis of the platform and the reason it can serve as both corpus layer and operator surface.

1,206Artifacts Cataloged

Manifest-backed catalog with type, date, entities, patterns, and summary metadata.

64Active Matters

Portfolio structure remains legible across a broad litigation workload.

197Behavioral Patterns

A full phenomenology registry makes recurring dynamics traceable across the corpus.

173Character Profiles

Role and actor modeling give the archive memory about who drives which outcomes.

6,000+Emails Processed

Normalized communication flows preserve timeline, leverage, and workflow context.

23Artifact Classes

Deposition, pleading, email, notes, records, and workflow objects live in one durable catalog.

Operator Value

More than storage, more than search

The real pitch is operational compression. Stonewall makes a litigation corpus usable under time pressure, not merely organized in hindsight.

This is where the platform becomes commercially legible: daily dossier visibility, deadline intelligence, workflow staging, and live tactical support all arise from the same indexed substrate.

Daily Dossier

Immediate situational awareness

The operator opens one surface and sees what changed, what is urgent, and which artifacts now matter today.

Deadline Intelligence

Runway instead of raw dates

Scattered source records become a usable agenda for upcoming work rather than a passive calendar dump.

Workflow Readiness

Prep without scavenger hunts

The same corpus supports deposition prep, mediation prep, intake triage, billing reconstruction, and chronology repair.

Production Guarantees

Validation built into the operating rhythm

Manifest checks, ontology enforcement, consistency scans, and deployment guards make the output trustworthy by design.

Innovation Stack

Eight layers working together

Each layer is modest in isolation. The novelty is how they reinforce one another: flat-file durability, CLI access, AI recall, workflow sync, and public deployment all hang off the same corpus discipline.

The showcase keeps the system legible to buyers, collaborators, and technically curious readers by focusing on architecture, leverage, and operator experience.

📚

Flat-File Searchable Database

catalog/manifest.md operates as a real database in Markdown. Every artifact receives a durable ID, date, type, matter link, entity links, pattern links, and summary text, with derivative indexes for date, case, character, pattern, and email lookups.

$ rg "deposition" catalog/manifest.md
$ rg "Pattern: BONEMAXXED" catalog/index_by_pattern.md

⌨️

CLI Intelligence Layer

The stdlib-only CLI makes the corpus queryable without standing up a server or a database engine. It handles stats, matter views, pattern lookups, timelines, validation, and artifact inspection from one consistent interface.

$ python scripts/stonewall.py stats
$ python scripts/stonewall.py case "Motor Vehicle Case A"

🧠

AI Recall Architecture

The brain is explicit recall architecture, not mystery memory. Codex files point the model to source surfaces first, then require reading before assertions, with version lineage preserved through frozen snapshots up to v10.4.

brain/
  cast_codex.md
  cases_codex.md
  phenomenology_codex.md

⚙️

Automated Ingestion Pipeline

Documents move from the source reservoir into normalized Markdown sidecars, OCR-assisted PDF transcriptions, DOCX conversions, and email imports. The result is a searchable corpus that remains Git-native.

ingest_onedrive.py
transcribe_repo_pdfs.py
docx_to_verbatim_md.py

🔄

Multi-Platform Sync

GitHub stores the durable corpus, OneDrive remains the source reservoir, and Notion becomes the operator layer for live matter management, task runway, and daily command views. Cross-reference manifests keep IDs aligned across surfaces.

python scripts/notion_wire_cases.py
python scripts/notion_case_dates.py

🛡️

Verification & QC Automation

Repo consistency checks, ontology enforcement, sidecar audits, and deployment guards make the output structurally sound. The same discipline that protects the corpus also increases commercial credibility.

$ python scripts/stonewall.py validate --strict
0 error(s), 153 warning(s) across 1206 rows

🧭

Phenomenology Registry

Stonewall tracks a 197-pattern behavioral taxonomy that can be instantiated across artifacts and traced longitudinally across the corpus.

$ python scripts/stonewall.py pattern "THEARTOFTHEDEALMAXXED"

🖥️

Static Portal

The portal proves that a multi-page operational dashboard can run as a fully static site from JSON snapshots alone. Dashboard, matters, deadlines, artifacts, patterns, cast, billing-style totals, and local settings all render without a backend in the live build.

docs/portal/
  index.html
  data/*.json

Tactical Workflow Layer

Notion, DataGavel, and live deposition tailoring

This is the part that moves the system from impressive archive to working legal machine. The repository remains the durable evidence trail while tactical layers turn the same corpus into forward motion.

The workflow thesis is direct: Stonewall is valuable because it stages the next move faster and more coherently than scattered folders, ad hoc notes, or one-off searches.

Notion as Operator Layer

Live command surface

Stonewall is strongest when the repository and Notion do different jobs well. The repository preserves the durable archive; Notion turns that into matter posture, archive relations, task runway, and daily operational control.

python scripts/notion_wire_cases.py
python scripts/notion_case_dates.py
node scripts/repo_data_push.mjs

DataGavel Workflow Readiness

Report packets staged upstream

Records can be pulled into a chronology, treatment trails checked, and damages notes staged into a packet that is ready for valuation or report work instead of requiring another scavenger hunt.

records pulled
→ chronology checked
→ treatment ledger aligned
→ damages notes staged
→ report packet ready

Live Deposition Tailoring

Outline tightening while the room is still warm

Because transcripts, filings, emails, and notes all live in one indexed corpus, the operator can sharpen the next section of an outline in real time by surfacing prior statements, chronology gaps, and issue clusters.

python scripts/stonewall.py find "corporate representative"
python scripts/stonewall.py timeline --start 2025-02-01 --end 2025-02-28
python scripts/stonewall.py show A1104

Architecture

Pipeline from source reservoir to static command surface

The architecture is visible enough to show why the platform works and why it is commercially credible.

The charm here is not just automation. It is the refusal to require a heavyweight backend before the operator can have useful control over a large corpus.

OneDrive / Source Reservoir
            |
            v
      Ingestion Layer
  ingest_onedrive.py
  transcribe_repo_pdfs.py
  docx_to_verbatim_md.py
            |
            v
      Processing Layer
  sidecars / normalization / tagging
            |
            v
        Notion Sync
  notion_wire_cases.py
  notion_wire_batch.py
  notion_case_dates.py
            |
            v
         Catalog Layer
  manifest.md + derivative indexes
            |
            v
          CLI Query
  stats / find / case / pattern / timeline
            |
            v
        Static Portal
  site-data.json + docs/portal/data/*.json

CLI Demo

Command examples from the operating surface

The examples below show the interface shape, query velocity, and validation discipline that make the platform useful under pressure.

The key product point is velocity: a lawyer can query, validate, and reorient the corpus from the terminal with no external dependencies and no opaque search appliance.

stats

$ python scripts/stonewall.py stats
total rows      : 1206
active          : 1122
analyzed        : 731 (65.2%)
patterns        : 197
characters      : 173
cases           : 64

find

$ python scripts/stonewall.py find "deposition"
A0198  Public Deposition Transcript    2025-02-28  deposition
A0441  Expert Deposition Outline       2025-07-16  deposition
A0917  Corporate Representative Prep   2026-01-11  deposition

validate

$ python scripts/stonewall.py validate --strict
0 error(s), 153 warning(s) across 1206 rows
ontology          : pass
filesystem links  : pass
date checks       : pass

Portal Preview

Static dashboard, real product energy

The included portal is the operator-facing face of the platform. It demonstrates how structured JSON snapshots can power a dashboard, matter view, deadlines board, artifact browser, and pattern registry with no backend required.

Pages is the immediate reveal surface. The official brief is the print edition. GitBook is the durable narrative layer. Together they present one coherent argument instead of a pile of disconnected docs.