bigmerge
e5c80359a8
New hard invariant (Will): only the orchestrator mutates global engram state; workers are read-only against the full engram + write only their own local geometry. This is an AUTHORITY gate (capability), not a health gate — a worker is STRUCTURALLY UNABLE to mutate global engram state regardless of engram health. - containment.el: scope tokens now carry a caps set. Orchestrator token holds engram:write + dharma:emit (@manager-only, the VBD rule that only the manager mutates global state); worker token holds ONLY engram:read. Rule 4: containment_check_engram_write / _dharma_emit reject any caller lacking the capability — same scope-token mechanism as the live Rule-2 denial. - swarm.el: swarm_engram_write is the ONLY engram write path, gated by Rule 4; a worker token is denied before any HTTP is issued (no mutation). The curated merge (commit=1) is the sole writer: the orchestrator commits approved geometry via its write-capable token. Workers' full-engram READ stays intact. - reshape_surface.el: compose op_write (json_escape_string) for the commit path. - harness: Rule-4 suite proven — worker engram-write DENIED by capability, no node created, violation journalled; orchestrator passes the gate as sole writer. 24/24 green on the :8901 clone with real cognition. Authority gate holds independent of daemon write-health (proven with daemon both alive and, earlier, crashed). Prod :8742 untouched.
120 lines
8.0 KiB
EmacsLisp
120 lines
8.0 KiB
EmacsLisp
// 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
|
|
}
|