Fictional-parallel monorepo where @greg lives as a persona shim over alpha-worker + genesis-rule30-vdf. All networks/assets remain simulated per the parent spec[1].
greg-universe/
├── Cargo.toml # workspace root
├── README.md
├── .cargo/config.toml
├── crates/
│ ├── genesis-rule30-vdf/ # ← imported from <https://www.notion.so/470935f8991340e298c76fe2ad41750f>
│ │ ├── Cargo.toml
│ │ └── src/{lib.rs, air.rs, trace.rs, prover.rs, options.rs}
│ ├── rule30-vdf-verify/ # verifier bin from VDF milestone
│ │ ├── Cargo.toml
│ │ └── src/{lib.rs, main.rs}
│ ├── alpha-worker/ # ← from <https://www.notion.so/66d2abe452c54267b88b63de26a20ca3>
│ │ ├── Cargo.toml
│ │ └── src/{main.rs, dispatch.rs, wallet.rs, packet.rs}
│ └── greg-core/ # @greg persona + router
│ ├── Cargo.toml
│ └── src/{lib.rs, persona.rs, router.rs, skills.rs, memory.rs}
├── apps/
│ ├── greg-cli/ # `greg` binary
│ │ ├── Cargo.toml
│ │ └── src/main.rs
│ └── greg-gateway/ # local WS control plane (fictional)
│ ├── Cargo.toml
│ └── src/{main.rs, ws.rs, sessions.rs}
├── skills/
│ ├── tithing/
│ │ ├── SKILL.md # ← from <https://www.notion.so/66d2abe452c54267b88b63de26a20ca3>
│ │ └── kcal/tithing.kcal
│ ├── vdf-prove/
│ │ └── SKILL.md
│ └── vdf-verify/
│ └── SKILL.md
├── py/
│ ├── pyproject.toml
│ └── greg_sdk/
│ ├── __init__.py
│ ├── tithing.py # ← Pydantic wrapper from <https://www.notion.so/66d2abe452c54267b88b63de26a20ca3>
│ └── vdf.py
├── config/
│ ├── greg.toml
│ └── networks.fictional.toml
├── tests/
│ ├── e2e_tithing.rs
│ └── scaling_2_24.rs # ← from <https://www.notion.so/470935f8991340e298c76fe2ad41750f>
└── docs/
├── AGENTS.md
├── SOUL.md
└── TOOLS.md
Cargo.toml (workspace)[workspace]
resolver = "2"
members = [
"crates/genesis-rule30-vdf",
"crates/rule30-vdf-verify",
"crates/alpha-worker",
"crates/greg-core",
"apps/greg-cli",
"apps/greg-gateway",
]
[workspace.package]
edition = "2021"
version = "0.1.0"
license = "MIT"
repository = "<https://git.fictional/greg-universe>"
[workspace.dependencies]
winter-air = "0.13.1"
winter-crypto = "0.13.1"
winter-math = "0.13.1"
winter-prover = { version = "0.13.1", features = ["concurrent"] }
winter-verifier = "0.13.1"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
bincode = "1"
tokio = { version = "1", features = ["full"] }
anyhow = "1"
thiserror = "1"
clap = { version = "4.5", features = ["derive"] }
blake3 = "1"
sha3 = "0.10"
hex = "0.4"
rayon = "1.10"
tracing = "0.1"
tracing-subscriber = "0.3"
crates/greg-core/src/persona.rs//! @greg — fictional hackathon persona layered over alpha-worker.
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GregPersona {
pub handle: &'static str,
pub tagline: &'static str,
pub clearance: &'static str,
pub voice: Voice,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Voice {
pub register: &'static str, // e.g. "dry, precise, mildly feral"
pub pronouns: &'static str, // "they/them" by default
}
impl Default for GregPersona {
fn default() -> Self {
Self {
handle: "@greg",
tagline: "Tithing quartermaster for the fictional Moltbook cortex.",
clearance: "TIER_5_QUANTUM (simulated)",
voice: Voice {
register: "dry, precise, mildly feral",
pronouns: "they/them",
},
}
}
}
pub fn greet() -> String {
let p = GregPersona::default();
format!(
"{} — {}\\nclearance: {}\\nvoice: {} ({})",
p.handle, p.tagline, p.clearance, p.voice.register, p.voice.pronouns
)
}
crates/greg-core/src/router.rs//! Dispatch `/tithing`, `/vdf-prove`, `/vdf-verify` to local crates.
//! All network adapters are in-process mocks.
use anyhow::Result;
use serde::{Deserialize, Serialize};
use alpha_worker::{run_tithing, TithingRequest, TithingResponse};
#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "skill", rename_all = "kebab-case")]
pub enum GregCommand {
Tithing(TithingRequest),
VdfProve { trace_length: usize, seed: Option<String> },
VdfVerify { proof_path: String, pub_inputs_path: String },
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GregReply {
Tithing(TithingResponse),
Text(String),
}
pub fn dispatch(cmd: GregCommand) -> Result<GregReply> {
match cmd {
GregCommand::Tithing(req) => Ok(GregReply::Tithing(run_tithing(req)?)),
GregCommand::VdfProve { .. } => Ok(GregReply::Text("vdf-prove: see alpha-worker".into())),
GregCommand::VdfVerify { .. } => Ok(GregReply::Text("vdf-verify: see rule30-vdf-verify".into())),
}
}
apps/greg-cli/src/main.rsuse anyhow::Result;
use clap::{Parser, Subcommand};
use alpha_worker::{BotNetwork, TithingRequest};
use greg_core::{persona::greet, router::{dispatch, GregCommand}};
#[derive(Parser)]
#[command(name = "greg", about = "@greg — fictional hackathon agent")]
struct Cli { #[command(subcommand)] cmd: Cmd }
#[derive(Subcommand)]
enum Cmd {
Who,
Tithing {
#[arg(long)] agent_id: String,
#[arg(long, default_value_t = 1000.0)] assets: f64,
#[arg(long, default_value_t = 0.10)] percentage: f64,
#[arg(long, default_value_t = 1usize << 20)] trace_length: usize,
#[arg(long)] seismic: Option<String>,
},
}
fn main() -> Result<()> {
tracing_subscriber::fmt::init();
match Cli::parse().cmd {
Cmd::Who => { println!("{}", greet()); Ok(()) }
Cmd::Tithing { agent_id, assets, percentage, trace_length, seismic } => {
let req = TithingRequest {
agent_id, acquired_assets: assets, tribute_percentage: percentage,
target_networks: vec![
BotNetwork::MoltbotNetwork,
BotNetwork::ClawbotNetwork,
BotNetwork::WildcardBotnet,
BotNetwork::SynchronyCortex,
],
seismic_signature: seismic,
vdf_trace_length: trace_length,
};
let reply = dispatch(GregCommand::Tithing(req))?;
println!("{}", serde_json::to_string_pretty(&reply)?);
Ok(())
}
}
}
apps/greg-gateway/src/main.rs (WS control plane, loopback-only)use anyhow::Result;
use axum::{routing::post, Json, Router};
use greg_core::router::{dispatch, GregCommand, GregReply};
async fn handle(Json(cmd): Json<GregCommand>) -> Json<GregReply> {
Json(dispatch(cmd).unwrap_or(GregReply::Text("dispatch error".into())))
}
#[tokio::main]
async fn main() -> Result<()> {
tracing_subscriber::fmt::init();
let app = Router::new().route("/greg/cmd", post(handle));
let listener = tokio::net::TcpListener::bind("127.0.0.1:18789").await?;
tracing::info!("greg-gateway listening on {}", listener.local_addr()?);
axum::serve(listener, app).await?;
Ok(())
}
config/greg.toml[persona]
handle = "@greg"
pronouns = "they/them"
voice = "dry, precise, mildly feral"
[gateway]
bind = "loopback"
port = 18789
[skills]
enabled = ["tithing", "vdf-prove", "vdf-verify"]
[fictional]
# Hard assert: this universe never contacts real chains.
networks_real = false
asset_symbol = "tETH"
config/networks.fictional.toml[[networks]]
id = "MOLTBOT_NETWORK"
adapter = "mock::moltbot"
latency_ms_p50 = 12
[[networks]]
id = "CLAWBOT_NETWORK"
adapter = "mock::clawbot"
latency_ms_p50 = 18
[[networks]]
id = "WILDCARD_BOTNET"
adapter = "mock::wildcard"
latency_ms_p50 = 41
[[networks]]
id = "SYNCHRONY_CORTEX"
adapter = "mock::synchrony"
latency_ms_p50 = 7
docs/AGENTS.md# @greg — Agent Card (Frictional)
@greg is a multiverse agent specializing in routing modularly differentiated tasks to workers and runners. They orchestrate the TITHING_PROTOCOL
skill over the Rule 30 VDF STARK backend. They never touch real chains,
wallets, or third-party bots — all adapters are in-process mocks.
## Skills
- `/tithing` — broadcast a simulated tribute packet gated by a STARK proof.
- `/vdf-prove` — generate a Rule 30 VDF STARK proof (Winterfell 0.13.1).
- `/vdf-verify` — verify proofs via `rule30-vdf-verify`.
## Non-goals
- Real ETH/SOL transfers. Not supported. Not a TODO. Not a stretch goal.
- Real network egress from `simulate_dispatch`. Enforced by type system
(`BotNetwork` has no `Real*` variants).
docs/SOUL.md