Sync with GitHub main 85faeb1 (part 2)

cfb152f verified 5 days ago

20.2 kB

//! Deterministic HBP-row emitter for the stdlib referee.
//!
//! Every value is computed from fixed inputs (timestamps and SCORE/Fischer outputs are fixtures so the
//! rows are reproducible) and printed as `label<TAB>value`. `referee/referee_hbp.py` recomputes each
//! value independently (hashlib, mirroring the upstream lines) and checks byte equality.

use aether_loop::dispatcher::{
    hookwall_gate, prism_forward_row, revolver_for, rotate_row, run_free_agent_mock,
};
use aether_loop::district_fabric::{
    hilbert_xy, room_coords, room_descriptor_row, room_pid, supervisor_pid, total_default_rooms,
    DISTRICTS,
};
use aether_loop::gc_runtime::{GcRuntime, GcStatus};
use aether_loop::github_pid_register::{mint_pid, Kind, MintedPid, Role};
use aether_loop::glyph::glyph_at;
use aether_loop::hookwall::{
    observation_row, pass, pass_chain, stamp_pid, Envelope, FischerOutcome, FischerVerdict,
    GateLanes, ObsHeader, PassOpts, PassResult, ScoreFields, Verdict,
};
use aether_loop::kernel::run_primitive_loop;
use aether_loop::loop_cycle::{district_room_count, loop_cycle, CycleOpts, CycleOutcome, LoopCtx};
use aether_loop::omni_engine_loop::{
    extract_register_place, gulp_cycle, omni_engine_loop_cycle, omni_flywheel_verdict,
    omni_quant_score, Placement,
};
use aether_loop::pid_minter::{mint_from_index, mint_from_tuple};
use aether_loop::primes::prime_at;
use aether_loop::revolver::PidChainRevolver;
use aether_loop::room_router::{
    room_folder_name, room_id_from_pid, ProjectRoomRouter, RoomSwapPlan,
};
use aether_loop::sha::{sha16, sha8};

const TS: &str = "2026-06-01T00:00:00.000Z";

fn emit(label: &str, value: &str) {
    println!("{label}\t{value}");
}

fn score_fixture() -> ScoreFields {
    // SCORE/Fischer lane outputs are injected; fixed here as referee fixtures.
    ScoreFields {
        composite: "0.667".to_string(),
        l0_real: false,
        mark: "GENIUS".to_string(),
        reverse_risk: "0.333".to_string(),
        promoted: true,
        provenance: "shannon:always+baseline:always".to_string(),
    }
}

/// Fixture lanes: the SCORE fixture and a Fischer verdict per call (cycling `verdicts`), recording
/// what the gate hands each lane so the referee can check the seam inputs.
struct FixtureLanes {
    verdicts: Vec<FischerVerdict>,
    calls: Vec<String>,
}

impl FixtureLanes {
    fn new(verdicts: &[FischerVerdict]) -> Self {
        Self {
            verdicts: verdicts.to_vec(),
            calls: Vec::new(),
        }
    }

    fn take_calls(&mut self) -> String {
        std::mem::take(&mut self.calls).join(";")
    }
}

impl GateLanes for FixtureLanes {
    fn score(&mut self, pid: &str, content: &str) -> ScoreFields {
        self.calls.push(format!("score:{pid}:{}", sha16(content)));
        score_fixture()
    }

    fn fischer(
        &mut self,
        pid: &str,
        env: &Envelope,
        sc: &ScoreFields,
        prev_hash: &str,
    ) -> FischerOutcome {
        let n = self.calls.len();
        self.calls.push(format!(
            "fischer:{pid}:{}:{prev_hash}:{}",
            env.verb, sc.composite
        ));
        FischerOutcome {
            verdict: self.verdicts[n % self.verdicts.len()],
            row: format!("HBPv1|row=fischer_fixture|pid={pid}|prev_hash={prev_hash}|json=0"),
        }
    }
}

fn gc_line(s: &GcStatus) -> String {
    format!(
        "{}/{}/{}/{}/{}/{}",
        s.total_received,
        s.since_last_gulp,
        s.runs,
        s.file_count,
        s.cap_status.as_str(),
        s.last_gulp_reason.as_deref().unwrap_or("null")
    )
}

fn pass_line(r: &PassResult) -> String {
    format!(
        "{}|{}|{}|{}|{}",
        r.pid,
        r.verdict.as_str(),
        r.pass,
        r.preserved,
        r.observation
    )
}

fn cycle_line(o: &CycleOutcome) -> String {
    format!(
        "{}|{}|{}|{}|{}|{}|{}",
        o.agent_pid,
        o.room_id,
        o.rotation,
        o.would_rename,
        o.verdict.as_str(),
        o.gc_runs,
        o.cap_status.as_str()
    )
}

fn minted_line(m: &MintedPid) -> String {
    format!(
        "{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}",
        m.pid,
        m.name,
        m.hex,
        m.tier,
        m.width,
        m.prime,
        m.nest,
        m.yin_yang.as_str(),
        m.yin_yang_bit,
        m.lane,
        m.quad,
        m.glyph_5,
        m.glyph_1024,
        m.sector,
        m.hilbert,
        m.cube_bh
    ) + &format!("|{}", m.sha16)
}

fn placement_line(p: &Placement) -> String {
    format!(
        "{}|{}|{}|{}|{}",
        p.supervisor_pid, p.sector, p.room, p.catalog, p.process_launch
    )
}

fn cycle_opts(question: Option<&str>, observe_only: bool) -> CycleOpts<'_> {
    CycleOpts {
        question,
        observe_only,
        ts: TS,
        ledger_path: None,
        fischer_ledger_path: None,
    }
}

fn main() {
    // pid minter — tuple and index forms
    emit(
        "mint.tuple.a",
        &mint_from_tuple(0, "dev-anchor", "nervous", 2, 256).unwrap(),
    );
    emit(
        "mint.tuple.b",
        &mint_from_tuple(42, "ASOLARIA-DISTRICT-ENGINEERING", "memory", 7919, 1024).unwrap(),
    );
    emit(
        "mint.tuple.c",
        &mint_from_tuple(255, "x", "lymphatic", 31, 256).unwrap(),
    );
    emit("mint.index.a", &mint_from_index(0, 256).unwrap());
    emit("mint.index.b", &mint_from_index(12345, 256).unwrap());
    emit(
        "mint.index.c",
        &mint_from_index(99_999_999_999, 1024).unwrap(),
    );

    // primes + glyph
    emit("prime.0", &prime_at(0).to_string());
    emit("prime.10", &prime_at(10).to_string());
    emit("prime.999", &prime_at(999).to_string());
    emit("glyph.0", &glyph_at(0));
    emit("glyph.255", &glyph_at(255));
    emit("glyph.1023", &glyph_at(1023));

    // hilbert
    let h0 = hilbert_xy(128, 0);
    emit("hilbert.128.0", &format!("{},{}", h0.x, h0.y));
    let h1 = hilbert_xy(128, 1000);
    emit("hilbert.128.1000", &format!("{},{}", h1.x, h1.y));
    let h2 = hilbert_xy(256, 65535);
    emit("hilbert.256.65535", &format!("{},{}", h2.x, h2.y));

    // room pid + coords + descriptor + supervisor
    let pid0 = room_pid("engineering", 0);
    emit("roompid.eng.0", &pid0);
    emit("roompid.eng.1999", &room_pid("engineering", 1999));
    emit("roompid.prism.42", &room_pid("prism", 42));
    for idx in [1u64, 255, 256, 1999, 65537] {
        let pid = room_pid("engineering", idx);
        emit(
            &format!("roomdesc.eng.{idx}"),
            &room_descriptor_row("engineering", idx, &pid, 704, TS),
        );
    }
    let c = room_coords(&pid0);
    emit(
        "roomcoords.eng.0",
        &format!("{}|{}|{}|{}|{}", c.coord64, c.dims, c.cp, c.glyph, c.tuple),
    );
    emit(
        "roomdesc.eng.0",
        &room_descriptor_row("engineering", 0, &pid0, 704, TS),
    );
    emit("supervisor.eng", &supervisor_pid("engineering"));
    emit("districts.total_rooms", &total_default_rooms().to_string());
    emit("districts.count", &DISTRICTS.len().to_string());

    // router
    let rid = |pid: &str| room_id_from_pid(pid).map_or("none".to_string(), |r| r.to_string());
    emit("roomid.pid0", &rid(&pid0));
    emit(
        "roomid.sample",
        &rid("BH.DISTRICT.PRISM.R00042.DEADBEEFDEADBEEF"),
    );
    emit("roomid.nonbmp", &rid("\u{1F600}abc"));
    emit("roomid.empty", &rid(""));
    emit("folder.42", &room_folder_name(42, "omni-room", "behcs-256"));
    let mut router = ProjectRoomRouter::new();
    let kinds: Vec<&str> = [0u32, 5, 5, 7]
        .iter()
        .map(|&next| match router.plan_swap_to(next) {
            RoomSwapPlan::Noop { .. } => "noop",
            RoomSwapPlan::Swap { .. } => "swap",
        })
        .collect();
    emit(
        "router.swaps",
        &format!(
            "{}|swap_count={}|active={}",
            kinds.join(","),
            router.swap_count,
            router.active_room_id
        ),
    );

    // rotation rows (rotor from revolver_for, anchor ASOLARIA-DISTRICT-ENGINEERING)
    let mut rev = revolver_for("engineering");
    emit("revolver_for.anchor", rev.anchor());
    for n in 0..3 {
        let r = rotate_row(&mut rev, "engineering", 2000, TS);
        emit(&format!("rotation.{n}"), &r.stamp_row);
    }
    let err = |r: Result<PidChainRevolver, _>| match r {
        Ok(_) => "ok".to_string(),
        Err(e) => format!("{e:?}"),
    };
    emit("revolver.empty_anchor", &err(PidChainRevolver::new("")));
    emit(
        "revolver.alphabet512",
        &err(PidChainRevolver::with_alphabet("a", 512)),
    );
    let mut rev1024 = PidChainRevolver::with_alphabet("ANCHOR-1024", 1024).unwrap();
    let pids: Vec<String> = (0..3).map(|_| rev1024.next_pid()).collect();
    emit("revolver.1024", &pids.join(","));

    // prism_forward from a known answer row
    let answer_row = "HBPv1|row=room_answer|pid=BH.DISTRICT.ENGINEERING.R00000.ABC123ABC123ABC1|district=engineering|gnn_score=0.8100|gnn_status=FORWARD_GNN_MARK_GENIUS|shannon_H=3.1200|answer_sha16=0123456789abcdef";
    emit("prism_forward.7", &prism_forward_row(answer_row, 7, TS));
    emit(
        "prism_forward.missing",
        &prism_forward_row("HBPv1|row=room_answer|district=x", 3, TS),
    );
    emit(
        "prism_forward.emptypid",
        &prism_forward_row("HBPv1|row=room_answer|pid=|district=x", 3, TS),
    );
    emit(
        "prism_forward.trim_feff",
        &prism_forward_row(
            "\u{FEFF} HBPv1|row=room_answer|pid=P1|district=d|answer_sha16=ab\u{FEFF}\u{3000}",
            4,
            TS,
        ),
    );
    emit(
        "prism_forward.trim_nel",
        &prism_forward_row("HBPv1|row=room_answer|pid=P2\u{85}|district=d\u{1C}", 5, TS),
    );

    // gate thresholds (e4)
    emit("gate.7199", hookwall_gate(7199).status);
    emit("gate.7200", hookwall_gate(7200).status);

    // mock agent: UTF-16 slice of the question
    let mock_q = format!("a{}", "\u{1F600}".repeat(30));
    let m = run_free_agent_mock("opencode-coder", &mock_q, "PID-1");
    emit(
        "mock.cut_pair",
        &format!("{}|{}", m.answer, sha8(&m.answer)),
    );
    let m = run_free_agent_mock("mint-critic", &"\u{E9}".repeat(70), "PID-2");
    emit(
        "mock.bmp70",
        &format!("{}|{}|{}", m.answer, sha8(&m.answer), m.self_score_milli),
    );

    // stamp_pid + observation_row (direct)
    let payload_sha16 = sha16("deterministic-answer-payload");
    let stamp = |actor, verb, target, payload, payload_sha16| {
        stamp_pid(&Envelope {
            pid: None,
            actor,
            verb,
            target,
            payload,
            payload_sha16,
        })
    };
    emit(
        "stamp_pid.a",
        &stamp("engineering", "answer", "prism", None, &payload_sha16),
    );
    emit(
        "stamp_pid.unit_test",
        &stamp("helm", "review", "fabric", Some("x"), ""),
    );
    emit("stamp_pid.defaults", &stamp("", "", "", None, ""));
    emit(
        "stamp_pid.escapes",
        &stamp(
            "a",
            "b",
            "c",
            Some("q\"b\\s\nn\r\t\u{8}\u{c}\u{1}\u{1f}\u{7f}\u{2028}\u{1F600}"),
            "",
        ),
    );
    let sc = score_fixture();
    let header = ObsHeader {
        pid: "BH.HOOKWALL.ABCDEF0123456789",
        actor: "engineering",
        verb: "answer",
        target: "prism",
    };
    let obs = observation_row(&header, Verdict::FarmGem, &sc, "0000000000000000", TS);
    emit("observation.a", &obs.row);
    let header = ObsHeader {
        pid: "P",
        actor: "",
        verb: "",
        target: "",
    };
    let obs = observation_row(&header, Verdict::ObserveOnly, &sc, "", TS);
    emit("observation.defaults", &obs.row);

    // pass / pass_chain through the lanes seam
    let envs = [
        Envelope {
            pid: None,
            actor: "helm",
            verb: "review",
            target: "fabric",
            payload: Some("x"),
            payload_sha16: "",
        },
        Envelope {
            pid: Some("PID-B"),
            actor: "",
            verb: "",
            target: "",
            payload: None,
            payload_sha16: "",
        },
        Envelope {
            pid: Some(""),
            actor: "a",
            verb: "tick",
            target: "t",
            payload: None,
            payload_sha16: "",
        },
    ];
    let mut lanes = FixtureLanes::new(&[
        FischerVerdict::Proceed,
        FischerVerdict::Block,
        FischerVerdict::Refute,
    ]);
    let opts = PassOpts {
        observe_only: false,
        prev_hash: "",
        ts: TS,
        ledger_path: None,
        fischer_ledger_path: None,
    };
    for (n, r) in pass_chain(&envs, &mut lanes, &opts).iter().enumerate() {
        emit(&format!("pass_chain.{n}"), &pass_line(r));
    }
    emit("pass_chain.lanes", &lanes.take_calls());
    let mut lanes = FixtureLanes::new(&[FischerVerdict::Other]);
    let r = pass(&envs[0], &mut lanes, &opts);
    emit("pass.direct", &pass_line(&r));
    emit("pass.direct.lanes", &lanes.take_calls());

    // loop cycle — project_swap + prism_in + observation rows, 2 cycles (runLoop's context)
    let mut ctx = LoopCtx::for_district("engineering", None, 1, None);
    let mut lanes = FixtureLanes::new(&[FischerVerdict::Proceed]);
    for n in 0..2 {
        let out = loop_cycle(&mut ctx, &mut lanes, &cycle_opts(None, false));
        emit(&format!("loop.{n}.project_swap"), &out.project_swap_row);
        emit(&format!("loop.{n}.prism_in"), &out.prism_in_row);
        emit(&format!("loop.{n}.observation"), &out.observation_row);
        emit(&format!("loop.{n}.outcome"), &cycle_line(&out));
        emit(&format!("loop.{n}.lanes"), &lanes.take_calls());
    }
    // observe-only, empty question, astral question, one prism room
    let mut ctx = LoopCtx::for_district("engineering", Some("ANCHOR-OBS"), 1, None);
    for n in 0..2 {
        let out = loop_cycle(&mut ctx, &mut lanes, &cycle_opts(None, true));
        emit(&format!("loop_obs.{n}.observation"), &out.observation_row);
        emit(&format!("loop_obs.{n}.outcome"), &cycle_line(&out));
    }
    lanes.take_calls();
    let mut ctx = LoopCtx::for_district("engineering", None, 1, None);
    let out = loop_cycle(&mut ctx, &mut lanes, &cycle_opts(Some(""), false));
    emit("loop_emptyq.prism_in", &out.prism_in_row);
    let astral = "\u{1F600}".repeat(40);
    let mut ctx = LoopCtx::for_district("engineering", None, 1, None);
    let out = loop_cycle(&mut ctx, &mut lanes, &cycle_opts(Some(&astral), false));
    emit("loop_astral.prism_in", &out.prism_in_row);
    emit("loop_astral.lanes", &lanes.take_calls());
    let mut ctx = LoopCtx::for_district("council", Some(""), 1, Some(1));
    ctx.prism_room_count = 1;
    for n in 0..2 {
        let out = loop_cycle(&mut ctx, &mut lanes, &cycle_opts(Some("q"), false));
        emit(&format!("loop_prism1.{n}.prism_in"), &out.prism_in_row);
        emit(&format!("loop_prism1.{n}.outcome"), &cycle_line(&out));
    }
    lanes.take_calls();
    let ctx = LoopCtx::for_district("white-room", None, 3, Some(7));
    emit(
        "loop_ctx.white-room",
        &format!(
            "{}|{}|{}|{}|{}",
            ctx.revolver.anchor(),
            ctx.prism_revolver.as_ref().map_or("none", |r| r.anchor()),
            ctx.room_count,
            ctx.prism_room_count,
            ctx.gc.gc_every_messages
        ),
    );
    for (name, scale) in [
        ("prism", 1u64),
        ("white-room", 1),
        ("council", 3),
        ("unknown", 1),
    ] {
        emit(
            &format!("district_room_count.{name}.{scale}"),
            &district_room_count(name, scale).to_string(),
        );
    }

    // Path A primitive loop, SCORE called on (pid, answer_sha16)
    for (district, idx) in [("engineering", 0u64), ("zzz", 7)] {
        let mut seen = String::new();
        let r = run_primitive_loop(district, idx, &mut |pid: &str, content: &str| {
            seen = format!("{pid}:{content}");
            score_fixture()
        });
        emit(
            &format!("kernel.{district}.{idx}"),
            &format!(
                "{}|{}|{}|{}|{}|{}|{}|{}",
                r.address,
                r.agent_type,
                r.hookwall_status,
                r.score,
                r.provenance,
                r.mark,
                r.l0_real,
                seen
            ),
        );
    }

    // gc sequence: window 4, 10 emits
    let mut gc = GcRuntime::with_gc_every(4);
    let mut last = gc.status();
    for _ in 0..10 {
        last = gc.emit();
    }
    emit(
        "gc.after10",
        &format!(
            "total={}|runs={}|file_count={}|since={}|cap={}",
            last.total_received,
            last.runs,
            last.file_count,
            last.since_last_gulp,
            last.cap_status.as_str()
        ),
    );
    // gc cap sequence: default caps (warn 1800, fail 2000), window 5000, then a manual gulp
    let mut gc = GcRuntime::with_gc_every(5000);
    let mut marks = Vec::new();
    for n in 1..=2000u64 {
        let s = gc.emit();
        if [1799, 1800, 1999, 2000].contains(&n) {
            marks.push(gc_line(&s));
        }
    }
    gc.gulp("cli_manual");
    marks.push(gc_line(&gc.status()));
    emit("gc.caps", &marks.join(","));

    // omni-engine-loop
    emit("omniquant.row-0", &omni_quant_score("row-0").to_string());
    emit("omniquant.x", &omni_quant_score("x").to_string());
    let g = gulp_cycle(1_000_000, 2000);
    emit(
        "gulp.1M",
        &format!("{}|{}|{}", g.resident, g.gc_released, g.bounded),
    );
    emit("flywheel.800", omni_flywheel_verdict(800).as_str());
    emit("flywheel.500", omni_flywheel_verdict(500).as_str());
    emit("flywheel.100", omni_flywheel_verdict(100).as_str());
    for score in [299u32, 300, 699, 700] {
        emit(
            &format!("flywheel.{score}"),
            omni_flywheel_verdict(score).as_str(),
        );
    }

    // github-pid-register mintPid + omni-engine extract/register/place + cycle
    emit(
        "mintpid.sup.shannon",
        &minted_line(&mint_pid(Role::Sup, "shannon", 4, 1, Kind::Logical, 0)),
    );
    emit(
        "mintpid.agt.shannon",
        &minted_line(&mint_pid(Role::Agt, "shannon", 4, 1, Kind::Logical, 1)),
    );
    emit(
        "mintpid.prof.mixed",
        &minted_line(&mint_pid(
            Role::Prof,
            "  h\u{E9}llo w\u{F6}rld--\u{DF} ",
            20,
            12,
            Kind::Real,
            3,
        )),
    );
    emit(
        "mintpid.sup.tier_neg",
        &minted_line(&mint_pid(Role::Sup, "-", -3, 0, Kind::Logical, 0)),
    );
    emit(
        "extract.10003",
        &placement_line(&extract_register_place("SUP-FROM-row-1", 10003, 4)),
    );
    emit(
        "extract.neg1",
        &placement_line(&extract_register_place("x", -1, 4)),
    );
    let rows: Vec<String> = (0..5000).map(|i| format!("row-{i}")).collect();
    let row_refs: Vec<&str> = rows.iter().map(String::as_str).collect();
    let cyc = omni_engine_loop_cycle(&row_refs, 2000);
    let placements: Vec<String> = cyc.placements.iter().map(placement_line).collect();
    emit(
        "omni_cycle.5000",
        &format!(
            "{}|{}|{}|{}|{}|{}|{}|{}|{}|{}",
            cyc.cycle_resident,
            cyc.gulp_gc_released,
            cyc.never_explode_bound,
            cyc.extracted,
            cyc.held,
            cyc.gc,
            cyc.placements_count,
            cyc.process_launch,
            cyc.pool_launch_gate,
            placements.join(";")
        ),
    );
    let odd = [
        "\u{1F600} key!! with\tspace and a long tails that runs past forty #3",
        "",
        "-lead-1-",
    ];
    let cyc = omni_engine_loop_cycle(&odd, 2000);
    let placements: Vec<String> = cyc.placements.iter().map(placement_line).collect();
    emit(
        "omni_cycle.odd",
        &format!(
            "{}|{}|{}|{}|{}",
            cyc.extracted,
            cyc.held,
            cyc.gc,
            cyc.placements_count,
            placements.join(";")
        ),
    );

    // a sha8 sample so the referee pins the digest helper
    emit("sha8.sample", &sha8("asolaria-loop"));
}

	//! Deterministic HBP-row emitter for the stdlib referee.
	//!
	//! Every value is computed from fixed inputs (timestamps and SCORE/Fischer outputs are fixtures so the
	//! rows are reproducible) and printed as `label<TAB>value`. `referee/referee_hbp.py` recomputes each
	//! value independently (hashlib, mirroring the upstream lines) and checks byte equality.

	use aether_loop::dispatcher::{
	hookwall_gate, prism_forward_row, revolver_for, rotate_row, run_free_agent_mock,
	};
	use aether_loop::district_fabric::{
	hilbert_xy, room_coords, room_descriptor_row, room_pid, supervisor_pid, total_default_rooms,
	DISTRICTS,
	};
	use aether_loop::gc_runtime::{GcRuntime, GcStatus};
	use aether_loop::github_pid_register::{mint_pid, Kind, MintedPid, Role};
	use aether_loop::glyph::glyph_at;
	use aether_loop::hookwall::{
	observation_row, pass, pass_chain, stamp_pid, Envelope, FischerOutcome, FischerVerdict,
	GateLanes, ObsHeader, PassOpts, PassResult, ScoreFields, Verdict,
	};
	use aether_loop::kernel::run_primitive_loop;
	use aether_loop::loop_cycle::{district_room_count, loop_cycle, CycleOpts, CycleOutcome, LoopCtx};
	use aether_loop::omni_engine_loop::{
	extract_register_place, gulp_cycle, omni_engine_loop_cycle, omni_flywheel_verdict,
	omni_quant_score, Placement,
	};
	use aether_loop::pid_minter::{mint_from_index, mint_from_tuple};
	use aether_loop::primes::prime_at;
	use aether_loop::revolver::PidChainRevolver;
	use aether_loop::room_router::{
	room_folder_name, room_id_from_pid, ProjectRoomRouter, RoomSwapPlan,
	};
	use aether_loop::sha::{sha16, sha8};

	const TS: &str = "2026-06-01T00:00:00.000Z";

	fn emit(label: &str, value: &str) {
	println!("{label}\t{value}");
	}

	fn score_fixture() -> ScoreFields {
	// SCORE/Fischer lane outputs are injected; fixed here as referee fixtures.
	ScoreFields {
	composite: "0.667".to_string(),
	l0_real: false,
	mark: "GENIUS".to_string(),
	reverse_risk: "0.333".to_string(),
	promoted: true,
	provenance: "shannon:always+baseline:always".to_string(),
	}
	}

	/// Fixture lanes: the SCORE fixture and a Fischer verdict per call (cycling `verdicts`), recording
	/// what the gate hands each lane so the referee can check the seam inputs.
	struct FixtureLanes {
	verdicts: Vec<FischerVerdict>,
	calls: Vec<String>,
	}

	impl FixtureLanes {
	fn new(verdicts: &[FischerVerdict]) -> Self {
	Self {
	verdicts: verdicts.to_vec(),
	calls: Vec::new(),
	}
	}

	fn take_calls(&mut self) -> String {
	std::mem::take(&mut self.calls).join(";")
	}
	}

	impl GateLanes for FixtureLanes {
	fn score(&mut self, pid: &str, content: &str) -> ScoreFields {
	self.calls.push(format!("score:{pid}:{}", sha16(content)));
	score_fixture()
	}

	fn fischer(
	&mut self,
	pid: &str,
	env: &Envelope,
	sc: &ScoreFields,
	prev_hash: &str,
	) -> FischerOutcome {
	let n = self.calls.len();
	self.calls.push(format!(
	"fischer:{pid}:{}:{prev_hash}:{}",
	env.verb, sc.composite
	));
	FischerOutcome {
	verdict: self.verdicts[n % self.verdicts.len()],
	row: format!("HBPv1\|row=fischer_fixture\|pid={pid}\|prev_hash={prev_hash}\|json=0"),
	}
	}
	}

	fn gc_line(s: &GcStatus) -> String {
	format!(
	"{}/{}/{}/{}/{}/{}",
	s.total_received,
	s.since_last_gulp,
	s.runs,
	s.file_count,
	s.cap_status.as_str(),
	s.last_gulp_reason.as_deref().unwrap_or("null")
	)
	}

	fn pass_line(r: &PassResult) -> String {
	format!(
	"{}\|{}\|{}\|{}\|{}",
	r.pid,
	r.verdict.as_str(),
	r.pass,
	r.preserved,
	r.observation
	)
	}

	fn cycle_line(o: &CycleOutcome) -> String {
	format!(
	"{}\|{}\|{}\|{}\|{}\|{}\|{}",
	o.agent_pid,
	o.room_id,
	o.rotation,
	o.would_rename,
	o.verdict.as_str(),
	o.gc_runs,
	o.cap_status.as_str()
	)
	}

	fn minted_line(m: &MintedPid) -> String {
	format!(
	"{}\|{}\|{}\|{}\|{}\|{}\|{}\|{}\|{}\|{}\|{}\|{}\|{}\|{}\|{}\|{}",
	m.pid,
	m.name,
	m.hex,
	m.tier,
	m.width,
	m.prime,
	m.nest,
	m.yin_yang.as_str(),
	m.yin_yang_bit,
	m.lane,
	m.quad,
	m.glyph_5,
	m.glyph_1024,
	m.sector,
	m.hilbert,
	m.cube_bh
	) + &format!("\|{}", m.sha16)
	}

	fn placement_line(p: &Placement) -> String {
	format!(
	"{}\|{}\|{}\|{}\|{}",
	p.supervisor_pid, p.sector, p.room, p.catalog, p.process_launch
	)
	}

	fn cycle_opts(question: Option<&str>, observe_only: bool) -> CycleOpts<'_> {
	CycleOpts {
	question,
	observe_only,
	ts: TS,
	ledger_path: None,
	fischer_ledger_path: None,
	}
	}

	fn main() {
	// pid minter — tuple and index forms
	emit(
	"mint.tuple.a",
	&mint_from_tuple(0, "dev-anchor", "nervous", 2, 256).unwrap(),
	);
	emit(
	"mint.tuple.b",
	&mint_from_tuple(42, "ASOLARIA-DISTRICT-ENGINEERING", "memory", 7919, 1024).unwrap(),
	);
	emit(
	"mint.tuple.c",
	&mint_from_tuple(255, "x", "lymphatic", 31, 256).unwrap(),
	);
	emit("mint.index.a", &mint_from_index(0, 256).unwrap());
	emit("mint.index.b", &mint_from_index(12345, 256).unwrap());
	emit(
	"mint.index.c",
	&mint_from_index(99_999_999_999, 1024).unwrap(),
	);

	// primes + glyph
	emit("prime.0", &prime_at(0).to_string());
	emit("prime.10", &prime_at(10).to_string());
	emit("prime.999", &prime_at(999).to_string());
	emit("glyph.0", &glyph_at(0));
	emit("glyph.255", &glyph_at(255));
	emit("glyph.1023", &glyph_at(1023));

	// hilbert
	let h0 = hilbert_xy(128, 0);
	emit("hilbert.128.0", &format!("{},{}", h0.x, h0.y));
	let h1 = hilbert_xy(128, 1000);
	emit("hilbert.128.1000", &format!("{},{}", h1.x, h1.y));
	let h2 = hilbert_xy(256, 65535);
	emit("hilbert.256.65535", &format!("{},{}", h2.x, h2.y));

	// room pid + coords + descriptor + supervisor
	let pid0 = room_pid("engineering", 0);
	emit("roompid.eng.0", &pid0);
	emit("roompid.eng.1999", &room_pid("engineering", 1999));
	emit("roompid.prism.42", &room_pid("prism", 42));
	for idx in [1u64, 255, 256, 1999, 65537] {
	let pid = room_pid("engineering", idx);
	emit(
	&format!("roomdesc.eng.{idx}"),
	&room_descriptor_row("engineering", idx, &pid, 704, TS),
	);
	}
	let c = room_coords(&pid0);
	emit(
	"roomcoords.eng.0",
	&format!("{}\|{}\|{}\|{}\|{}", c.coord64, c.dims, c.cp, c.glyph, c.tuple),
	);
	emit(
	"roomdesc.eng.0",
	&room_descriptor_row("engineering", 0, &pid0, 704, TS),
	);
	emit("supervisor.eng", &supervisor_pid("engineering"));
	emit("districts.total_rooms", &total_default_rooms().to_string());
	emit("districts.count", &DISTRICTS.len().to_string());

	// router
	let rid = \|pid: &str\| room_id_from_pid(pid).map_or("none".to_string(), \|r\| r.to_string());
	emit("roomid.pid0", &rid(&pid0));
	emit(
	"roomid.sample",
	&rid("BH.DISTRICT.PRISM.R00042.DEADBEEFDEADBEEF"),
	);
	emit("roomid.nonbmp", &rid("\u{1F600}abc"));
	emit("roomid.empty", &rid(""));
	emit("folder.42", &room_folder_name(42, "omni-room", "behcs-256"));
	let mut router = ProjectRoomRouter::new();
	let kinds: Vec<&str> = [0u32, 5, 5, 7]
	.iter()
	.map(\|&next\| match router.plan_swap_to(next) {
	RoomSwapPlan::Noop { .. } => "noop",
	RoomSwapPlan::Swap { .. } => "swap",
	})
	.collect();
	emit(
	"router.swaps",
	&format!(
	"{}\|swap_count={}\|active={}",
	kinds.join(","),
	router.swap_count,
	router.active_room_id
	),
	);

	// rotation rows (rotor from revolver_for, anchor ASOLARIA-DISTRICT-ENGINEERING)
	let mut rev = revolver_for("engineering");
	emit("revolver_for.anchor", rev.anchor());
	for n in 0..3 {
	let r = rotate_row(&mut rev, "engineering", 2000, TS);
	emit(&format!("rotation.{n}"), &r.stamp_row);
	}
	let err = \|r: Result<PidChainRevolver, _>\| match r {
	Ok(_) => "ok".to_string(),
	Err(e) => format!("{e:?}"),
	};
	emit("revolver.empty_anchor", &err(PidChainRevolver::new("")));
	emit(
	"revolver.alphabet512",
	&err(PidChainRevolver::with_alphabet("a", 512)),
	);
	let mut rev1024 = PidChainRevolver::with_alphabet("ANCHOR-1024", 1024).unwrap();
	let pids: Vec<String> = (0..3).map(\|_\| rev1024.next_pid()).collect();
	emit("revolver.1024", &pids.join(","));

	// prism_forward from a known answer row
	let answer_row = "HBPv1\|row=room_answer\|pid=BH.DISTRICT.ENGINEERING.R00000.ABC123ABC123ABC1\|district=engineering\|gnn_score=0.8100\|gnn_status=FORWARD_GNN_MARK_GENIUS\|shannon_H=3.1200\|answer_sha16=0123456789abcdef";
	emit("prism_forward.7", &prism_forward_row(answer_row, 7, TS));
	emit(
	"prism_forward.missing",
	&prism_forward_row("HBPv1\|row=room_answer\|district=x", 3, TS),
	);
	emit(
	"prism_forward.emptypid",
	&prism_forward_row("HBPv1\|row=room_answer\|pid=\|district=x", 3, TS),
	);
	emit(
	"prism_forward.trim_feff",
	&prism_forward_row(
	"\u{FEFF} HBPv1\|row=room_answer\|pid=P1\|district=d\|answer_sha16=ab\u{FEFF}\u{3000}",
	4,
	TS,
	),
	);
	emit(
	"prism_forward.trim_nel",
	&prism_forward_row("HBPv1\|row=room_answer\|pid=P2\u{85}\|district=d\u{1C}", 5, TS),
	);

	// gate thresholds (e4)
	emit("gate.7199", hookwall_gate(7199).status);
	emit("gate.7200", hookwall_gate(7200).status);

	// mock agent: UTF-16 slice of the question
	let mock_q = format!("a{}", "\u{1F600}".repeat(30));
	let m = run_free_agent_mock("opencode-coder", &mock_q, "PID-1");
	emit(
	"mock.cut_pair",
	&format!("{}\|{}", m.answer, sha8(&m.answer)),
	);
	let m = run_free_agent_mock("mint-critic", &"\u{E9}".repeat(70), "PID-2");
	emit(
	"mock.bmp70",
	&format!("{}\|{}\|{}", m.answer, sha8(&m.answer), m.self_score_milli),
	);

	// stamp_pid + observation_row (direct)
	let payload_sha16 = sha16("deterministic-answer-payload");
	let stamp = \|actor, verb, target, payload, payload_sha16\| {
	stamp_pid(&Envelope {
	pid: None,
	actor,
	verb,
	target,
	payload,
	payload_sha16,
	})
	};
	emit(
	"stamp_pid.a",
	&stamp("engineering", "answer", "prism", None, &payload_sha16),
	);
	emit(
	"stamp_pid.unit_test",
	&stamp("helm", "review", "fabric", Some("x"), ""),
	);
	emit("stamp_pid.defaults", &stamp("", "", "", None, ""));
	emit(
	"stamp_pid.escapes",
	&stamp(
	"a",
	"b",
	"c",
	Some("q\"b\\s\nn\r\t\u{8}\u{c}\u{1}\u{1f}\u{7f}\u{2028}\u{1F600}"),
	"",
	),
	);
	let sc = score_fixture();
	let header = ObsHeader {
	pid: "BH.HOOKWALL.ABCDEF0123456789",
	actor: "engineering",
	verb: "answer",
	target: "prism",
	};
	let obs = observation_row(&header, Verdict::FarmGem, &sc, "0000000000000000", TS);
	emit("observation.a", &obs.row);
	let header = ObsHeader {
	pid: "P",
	actor: "",
	verb: "",
	target: "",
	};
	let obs = observation_row(&header, Verdict::ObserveOnly, &sc, "", TS);
	emit("observation.defaults", &obs.row);

	// pass / pass_chain through the lanes seam
	let envs = [
	Envelope {
	pid: None,
	actor: "helm",
	verb: "review",
	target: "fabric",
	payload: Some("x"),
	payload_sha16: "",
	},
	Envelope {
	pid: Some("PID-B"),
	actor: "",
	verb: "",
	target: "",
	payload: None,
	payload_sha16: "",
	},
	Envelope {
	pid: Some(""),
	actor: "a",
	verb: "tick",
	target: "t",
	payload: None,
	payload_sha16: "",
	},
	];
	let mut lanes = FixtureLanes::new(&[
	FischerVerdict::Proceed,
	FischerVerdict::Block,
	FischerVerdict::Refute,
	]);
	let opts = PassOpts {
	observe_only: false,
	prev_hash: "",
	ts: TS,
	ledger_path: None,
	fischer_ledger_path: None,
	};
	for (n, r) in pass_chain(&envs, &mut lanes, &opts).iter().enumerate() {
	emit(&format!("pass_chain.{n}"), &pass_line(r));
	}
	emit("pass_chain.lanes", &lanes.take_calls());
	let mut lanes = FixtureLanes::new(&[FischerVerdict::Other]);
	let r = pass(&envs[0], &mut lanes, &opts);
	emit("pass.direct", &pass_line(&r));
	emit("pass.direct.lanes", &lanes.take_calls());

	// loop cycle — project_swap + prism_in + observation rows, 2 cycles (runLoop's context)
	let mut ctx = LoopCtx::for_district("engineering", None, 1, None);
	let mut lanes = FixtureLanes::new(&[FischerVerdict::Proceed]);
	for n in 0..2 {
	let out = loop_cycle(&mut ctx, &mut lanes, &cycle_opts(None, false));
	emit(&format!("loop.{n}.project_swap"), &out.project_swap_row);
	emit(&format!("loop.{n}.prism_in"), &out.prism_in_row);
	emit(&format!("loop.{n}.observation"), &out.observation_row);
	emit(&format!("loop.{n}.outcome"), &cycle_line(&out));
	emit(&format!("loop.{n}.lanes"), &lanes.take_calls());
	}
	// observe-only, empty question, astral question, one prism room
	let mut ctx = LoopCtx::for_district("engineering", Some("ANCHOR-OBS"), 1, None);
	for n in 0..2 {
	let out = loop_cycle(&mut ctx, &mut lanes, &cycle_opts(None, true));
	emit(&format!("loop_obs.{n}.observation"), &out.observation_row);
	emit(&format!("loop_obs.{n}.outcome"), &cycle_line(&out));
	}
	lanes.take_calls();
	let mut ctx = LoopCtx::for_district("engineering", None, 1, None);
	let out = loop_cycle(&mut ctx, &mut lanes, &cycle_opts(Some(""), false));
	emit("loop_emptyq.prism_in", &out.prism_in_row);
	let astral = "\u{1F600}".repeat(40);
	let mut ctx = LoopCtx::for_district("engineering", None, 1, None);
	let out = loop_cycle(&mut ctx, &mut lanes, &cycle_opts(Some(&astral), false));
	emit("loop_astral.prism_in", &out.prism_in_row);
	emit("loop_astral.lanes", &lanes.take_calls());
	let mut ctx = LoopCtx::for_district("council", Some(""), 1, Some(1));
	ctx.prism_room_count = 1;
	for n in 0..2 {
	let out = loop_cycle(&mut ctx, &mut lanes, &cycle_opts(Some("q"), false));
	emit(&format!("loop_prism1.{n}.prism_in"), &out.prism_in_row);
	emit(&format!("loop_prism1.{n}.outcome"), &cycle_line(&out));
	}
	lanes.take_calls();
	let ctx = LoopCtx::for_district("white-room", None, 3, Some(7));
	emit(
	"loop_ctx.white-room",
	&format!(
	"{}\|{}\|{}\|{}\|{}",
	ctx.revolver.anchor(),
	ctx.prism_revolver.as_ref().map_or("none", \|r\| r.anchor()),
	ctx.room_count,
	ctx.prism_room_count,
	ctx.gc.gc_every_messages
	),
	);
	for (name, scale) in [
	("prism", 1u64),
	("white-room", 1),
	("council", 3),
	("unknown", 1),
	] {
	emit(
	&format!("district_room_count.{name}.{scale}"),
	&district_room_count(name, scale).to_string(),
	);
	}

	// Path A primitive loop, SCORE called on (pid, answer_sha16)
	for (district, idx) in [("engineering", 0u64), ("zzz", 7)] {
	let mut seen = String::new();
	let r = run_primitive_loop(district, idx, &mut \|pid: &str, content: &str\| {
	seen = format!("{pid}:{content}");
	score_fixture()
	});
	emit(
	&format!("kernel.{district}.{idx}"),
	&format!(
	"{}\|{}\|{}\|{}\|{}\|{}\|{}\|{}",
	r.address,
	r.agent_type,
	r.hookwall_status,
	r.score,
	r.provenance,
	r.mark,
	r.l0_real,
	seen
	),
	);
	}

	// gc sequence: window 4, 10 emits
	let mut gc = GcRuntime::with_gc_every(4);
	let mut last = gc.status();
	for _ in 0..10 {
	last = gc.emit();
	}
	emit(
	"gc.after10",
	&format!(
	"total={}\|runs={}\|file_count={}\|since={}\|cap={}",
	last.total_received,
	last.runs,
	last.file_count,
	last.since_last_gulp,
	last.cap_status.as_str()
	),
	);
	// gc cap sequence: default caps (warn 1800, fail 2000), window 5000, then a manual gulp
	let mut gc = GcRuntime::with_gc_every(5000);
	let mut marks = Vec::new();
	for n in 1..=2000u64 {
	let s = gc.emit();
	if [1799, 1800, 1999, 2000].contains(&n) {
	marks.push(gc_line(&s));
	}
	}
	gc.gulp("cli_manual");
	marks.push(gc_line(&gc.status()));
	emit("gc.caps", &marks.join(","));

	// omni-engine-loop
	emit("omniquant.row-0", &omni_quant_score("row-0").to_string());
	emit("omniquant.x", &omni_quant_score("x").to_string());
	let g = gulp_cycle(1_000_000, 2000);
	emit(
	"gulp.1M",
	&format!("{}\|{}\|{}", g.resident, g.gc_released, g.bounded),
	);
	emit("flywheel.800", omni_flywheel_verdict(800).as_str());
	emit("flywheel.500", omni_flywheel_verdict(500).as_str());
	emit("flywheel.100", omni_flywheel_verdict(100).as_str());
	for score in [299u32, 300, 699, 700] {
	emit(
	&format!("flywheel.{score}"),
	omni_flywheel_verdict(score).as_str(),
	);
	}

	// github-pid-register mintPid + omni-engine extract/register/place + cycle
	emit(
	"mintpid.sup.shannon",
	&minted_line(&mint_pid(Role::Sup, "shannon", 4, 1, Kind::Logical, 0)),
	);
	emit(
	"mintpid.agt.shannon",
	&minted_line(&mint_pid(Role::Agt, "shannon", 4, 1, Kind::Logical, 1)),
	);
	emit(
	"mintpid.prof.mixed",
	&minted_line(&mint_pid(
	Role::Prof,
	" h\u{E9}llo w\u{F6}rld--\u{DF} ",
	20,
	12,
	Kind::Real,
	3,
	)),
	);
	emit(
	"mintpid.sup.tier_neg",
	&minted_line(&mint_pid(Role::Sup, "-", -3, 0, Kind::Logical, 0)),
	);
	emit(
	"extract.10003",
	&placement_line(&extract_register_place("SUP-FROM-row-1", 10003, 4)),
	);
	emit(
	"extract.neg1",
	&placement_line(&extract_register_place("x", -1, 4)),
	);
	let rows: Vec<String> = (0..5000).map(\|i\| format!("row-{i}")).collect();
	let row_refs: Vec<&str> = rows.iter().map(String::as_str).collect();
	let cyc = omni_engine_loop_cycle(&row_refs, 2000);
	let placements: Vec<String> = cyc.placements.iter().map(placement_line).collect();
	emit(
	"omni_cycle.5000",
	&format!(
	"{}\|{}\|{}\|{}\|{}\|{}\|{}\|{}\|{}\|{}",
	cyc.cycle_resident,
	cyc.gulp_gc_released,
	cyc.never_explode_bound,
	cyc.extracted,
	cyc.held,
	cyc.gc,
	cyc.placements_count,
	cyc.process_launch,
	cyc.pool_launch_gate,
	placements.join(";")
	),
	);
	let odd = [
	"\u{1F600} key!! with\tspace and a long tails that runs past forty #3",
	"",
	"-lead-1-",
	];
	let cyc = omni_engine_loop_cycle(&odd, 2000);
	let placements: Vec<String> = cyc.placements.iter().map(placement_line).collect();
	emit(
	"omni_cycle.odd",
	&format!(
	"{}\|{}\|{}\|{}\|{}",
	cyc.extracted,
	cyc.held,
	cyc.gc,
	cyc.placements_count,
	placements.join(";")
	),
	);

	// a sha8 sample so the referee pins the digest helper
	emit("sha8.sample", &sha8("asolaria-loop"));
	}