I build deterministic developer infrastructure: schema compilers, Git-native provenance systems, replayable runtimes, terminal UI tooling, and agent-safe repo context systems. Most of the work is Rust and TypeScript.

The common thread: software history should be explicit, replayable, and inspectable.

• Bijou — Runnable terminal UI toolkit. Real character grid, layout engine, i18n, deterministic render output.
• Wesley — GraphQL SDL compiler. One schema drives TypeScript, Rust, SQL, manifests, and runtime plans.
• Graft — Context governor for coding agents. Policy-enforced repo reads and structural views.
• Echo — Deterministic application runtime where state is a materialized view over causal history.
• git-warp — Git-native causal history engine for replayable provenance, speculative branches, and canonical history.

mindmap
  root((Ecosystem))
    Start Here
      Bijou
      Wesley
      Graft
      Echo
      git-warp
    Research
      AIΩN Foundation Series
      Observer Geometry Series
      WARP Drive
    Foundations
      Continuum
      Wesley
    Runtimes & Apps
      Echo
        jedit
      git-warp
        Think
        Xyph
    Agent Infrastructure
      Graft
      blacklight
    Libraries
      Bijou
      Alfred
      Nine Lives
      git-cas
    Tools & Debugging
      WARP-TTD
      Geordi
      Shiplog
      METHOD

Most developer systems still inherit the Unix model: processes mutate files, logs are best-effort, and history is whatever someone remembered to record.

That model scales surprisingly far, but it breaks down under concurrency, distribution, and automation. Once humans, services, and agents are all changing state, the basic questions become hard:

• What actually happened?
• Who or what caused it?
• What did each actor see?
• Can we replay, fork, or verify the result?

This work explores a post-Unix runtime model:

• Processes become named actors in a shared causal history.
• Files become materialized views over history, not the source of truth.
• State changes become append-only events with verifiable provenance.
• Time is represented by causal structure, not loose wall-clock timestamps.
• Runtimes own admission, ordering, and replay; applications submit intents and consume evidence.

The goal is systems that remember what happened well enough to replay it, not better logs. Don’t hope your editor, planner, and agents are in sync; ask what the shared history allows each of them to see.

• Continuum defines the shared causal-history protocol.
• Wesley compiles schemas and contracts into code, plans, and runtime artifacts.
• Echo and git-warp are sibling runtimes over deterministic, replayable history.
• Graft and blacklight are the agent-infrastructure layer.
• Bijou, jedit, Think, and Xyph are interfaces and applications built around the model.
• Alfred, Nine Lives, and git-cas provide supporting resilience and storage infrastructure.
• WARP-TTD, Shiplog, Geordi, and METHOD are tools for debugging, deployment, UI IR, and engineering process.

The implementation work is backed by a formal research layer.

• AIΩN Foundation Series defines the core WARP model: WARP graphs, deterministic state evolution, computational holography, provenance payloads, observer-relative dynamics, and replay ethics.
• Observer Geometry Series formalizes how bounded observers see, compare, and justify claims over shared causal history.
• Governance & Ethics explores rights, safety, and accountability for systems whose histories can be replayed, inspected, or forked.