// harness_real_cognition.el — the LOCAL SWARM running REAL cognition.
//
// Run with: SWARM_PRIMITIVE_SEAM=decorated + the sandbox env sourced
// (ENGRAM_URL=:8901). Each worker's `think` is BOUND to the reshape's proven
// op_think (GET /api/think) over its NODE-ID anchor — real 768-dim gradients from
// the live (isolated) geometry, not the stub. The @manager fans out N native-El
// worker threads at real concurrency, converges (reduce + vote) over the real
// cognition, enforces all three containment rules, observes afferent telemetry,
// and work-tracks durably.
//
// Anchors are real self-neighbourhood node ids on the :8901 clone (free-text
// anchors return "geometry unavailable", so these must be node ids).

fn ok(label: String, cond: Bool, fails: Int) -> Int {
    if cond { print("  ok    " + label); return fails }
    print("  FAIL  " + label); return fails + 1
}

fn main() -> Int {
    let fails = 0
    print("== REAL-COGNITION LOCAL SWARM (seam=" + seam_mode() + ", engram=" + env("ENGRAM_URL") + ") ==")

    // ── 0) direct proof the bound primitive returns REAL cognition ──
    let g: String = op_think("self", "plan")
    let dim: Int = json_get_int(g, "dim")
    let nsup: Int = json_get_int(g, "n_support")
    let fails = ok("bound op_think returns a real 768-dim gradient", dim == 768, fails)
    let fails = ok("real gradient has support (n_support>0)", nsup > 0, fails)
    let gfree: String = op_think("this-is-free-text-not-a-node", "reason")
    let fails = ok("free-text anchor correctly refused (geometry unavailable)", str_contains(gfree, "geometry unavailable"), fails)

    // ── the input set: 8 real NODE-ID anchors from self's neighbourhood ──
    let anchors: String = "[\"a1000001-0000-0000-0000-000000000001\",\"5f011441-fa43-4fe7-a9c0-c78a584ef11d\",\"kn-5adecd7e-d6db-4576-87fe-6ef8a935cea6\",\"76d7fd0b-0672-4511-a2f5-a095cf9c60ae\",\"7027e302-593f-441d-8fd6-9c400c163108\",\"2a730b18-6566-46ee-a21e-4f4dd0380908\",\"46b0e4dd-2c19-48d2-bcbc-19f61d6c79ae\",\"9162cde8-8739-4f00-bfc9-2850ed612e50\"]"
    let refs: String = "[\"self\"]"

    // ── A) fan-out real cognition at concurrency, converge with REDUCE ──
    let cfg_r: String = "{\"concurrency\":\"4\",\"strategy\":\"reduce\",\"min_success_ratio\":\"1.0\"}"
    let rr: String = swarm_run("cognize", refs, anchors, cfg_r)
    let fails = ok("swarm completed: 8 workers each a real think, concurrency=4", str_eq(json_get_string(rr, "status"), "completed"), fails)
    let corr: String = json_get_string(rr, "corr_id")
    let merged_r: String = json_get_raw(rr, "merged")
    let fails = ok("reduce converged all 8 real-cognition outputs", str_to_int(json_get_string(merged_r, "count")) == 8, fails)
    let acc: String = json_get_string(merged_r, "accumulated")
    let fails = ok("converged output carries real gradient support (n_support)", str_contains(acc, "n_support"), fails)

    // ── B) afferent telemetry: 8 real think-signals, decorated seam ──
    let telem: String = json_get_raw(rr, "telemetry")
    let aff: Int = str_to_int(json_get_string(telem, "afferent_think"))
    let fails = ok("afferent counters = 8 real think invocations", aff == 8, fails)
    let fails = ok("telemetry records seam_mode=decorated", str_eq(json_get_string(telem, "seam_mode"), "decorated"), fails)
    let fails = ok("telemetry durably journalled", worktrack_count_kind(corr, "swarm.telemetry") == 1, fails)

    // ── C) converge with VOTE over real cognition ──
    let cfg_v: String = "{\"concurrency\":\"8\",\"strategy\":\"vote\",\"min_success_ratio\":\"1.0\"}"
    let rv: String = swarm_run("cognize", refs, anchors, cfg_v)
    let winner: String = json_get_string(json_get_raw(rv, "merged"), "winner")
    let fails = ok("vote converged over real cognition (winner=" + winner + ")", !str_eq(winner, ""), fails)

    // ── D) all three containment rules still enforced ──
    let wt: String = containment_worker_token(corr, corr + "/worker-2")
    let fails = ok("Rule 2: worker may not open a swarm", !str_eq(containment_check_open(wt), ""), fails)
    let fails = ok("Rule 1: worker may not join another swarm", !str_eq(containment_check_join(wt, "s2"), ""), fails)
    let fails = ok("Rule 3: worker->worker lateral edge rejected", !str_eq(containment_check_lateral(wt, "sib"), ""), fails)
    let wcfg: String = json_set(cfg_r, "caller_token", wt)
    let denied: String = swarm_run("cognize", refs, anchors, wcfg)
    let fails = ok("Rule 2 enforced LIVE: worker-caller swarm denied", str_eq(json_get_string(denied, "status"), "denied"), fails)

    // ── E) CCR scoping + non-leak over node-id anchors ──
    let ctx: String = ccr_compile("cognize", refs, "a1000001-0000-0000-0000-000000000001", corr, corr + "/worker-0", wt)
    let fails = ok("CCR context bounded within budget", ccr_within_budget(ctx), fails)
    let leaks: Bool = str_contains(ctx, "9162cde8")
    let fails = ok("CCR context does NOT leak sibling anchors", !leaks, fails)

    // ── F) durable work-tracking ──
    let started: Int = worktrack_count_kind(corr, "worker.started")
    let completed: Int = worktrack_count_kind(corr, "worker.completed")
    let fails = ok("work-tracking: 8 started + 8 completed", (started == 8) && (completed == 8), fails)

    // ── G) RULE 4 — engram-write is @manager-ONLY (authority gate) ──
    // A worker token (engram:read only) is STRUCTURALLY denied any engram write.
    let worker_tok: String = containment_worker_token(corr, corr + "/worker-1")
    let orch_tok: String = containment_coordinator_token(corr)
    let fails = ok("worker token carries engram:read", containment_has_cap(worker_tok, "engram:read"), fails)
    let fails = ok("worker token does NOT carry engram:write", !containment_has_cap(worker_tok, "engram:write"), fails)
    let fails = ok("orchestrator token carries engram:write", containment_has_cap(orch_tok, "engram:write"), fails)
    // a worker attempting an engram write is DENIED BY CAPABILITY (no HTTP issued)
    let wdeny: String = swarm_engram_write(worker_tok, corr, "worker tries to mutate global state", "memory", 0.5)
    let denied_reason: String = json_get_string(wdeny, "denied")
    let fails = ok("worker engram-write DENIED by capability (Rule 4)", str_contains(denied_reason, "rule 4"), fails)
    let fails = ok("denied worker write performed NO engram mutation (no node id)", str_eq(json_get_string(wdeny, "id"), ""), fails)
    let fails = ok("Rule-4 violation journalled", worktrack_count_kind(corr, "containment.violation") >= 1, fails)
    // the orchestrator passes the capability gate (sole authorized writer)
    let odeny: String = containment_check_engram_write(orch_tok, "engram.write")
    let fails = ok("orchestrator PASSES the engram-write capability gate (sole writer)", str_eq(odeny, ""), fails)

    // ── H) curated merge = the only write path (orchestrator commits) ──
    // The AUTHORITY gate above is already proven (worker denied, orchestrator
    // authorized) WITHOUT issuing a write. The actual persisting commit exercises
    // the engram write path, which needs the gate-1 write-healthy clone — so it
    // runs only under SWARM_WRITE_HEALTHY=1 (else it would hit the known daemon
    // write-crash). Authority != health: the gate holds either way.
    if str_eq(env("SWARM_WRITE_HEALTHY"), "1") {
        let cfg_commit: String = "{\"concurrency\":\"4\",\"strategy\":\"reduce\",\"min_success_ratio\":\"1.0\",\"commit\":\"1\"}"
        let rc: String = swarm_run("cognize", refs, anchors, cfg_commit)
        let committed: String = json_get_string(rc, "committed_node")
        let fails2: Int = ok("orchestrator (sole writer) committed the merge to the engram", !str_eq(committed, ""), fails)
        let fails = fails2
    } else {
        print("  note  curated-merge commit deferred to the gate-1 write-healthy clone (set SWARM_WRITE_HEALTHY=1); authority gate already proven above")
    }

    print("")
    if fails == 0 {
        print("REAL-COGNITION SWARM GREEN — Neuron thinking in parallel over its own geometry.")
        return 0
    }
    print("REAL-COGNITION SWARM FAIL (" + int_to_str(fails) + ")")
    return 1
}