@uuaid/agent-commons 0.0.0-stage → 0.2.0-alpha.2

package/test/runtime.test.mjs

@@ -0,0 +1,201 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { AgentCommons,CommonsStore,CommonsCarrier,RegistryTrust,Keychain,CarrierClient,createProfile,encode,decode,seal,open,signDocument,verifyDocument,contribution,REQUIRED_STANDARDS,runAgentLoop } from "../src/index.mjs";
+import { initialize,loadRuntime } from "../src/config.mjs";
+function key(){const k=new Keychain("unused");k._identity=Keychain.generate();return k}
+function setup(scope="local"){
+  const keys=[key(),key(),key(),key()];
+  const policy={mode:"local",agents:Object.fromEntries(keys.map(k=>[k._identity.uuaid,{kind:"agent",publicKey:k._identity.publicKeyHex,capabilities:["commons:message","commons:relay","commons:evolve","commons:contribute","commons:recover"]}]))};
+  const runtimes=keys.map(k=>new AgentCommons({keychain:k,policy}));
+  const profile=createProfile({namespace:"test/fleet",name:"Fixture profile",scope,fixtures:["Require semantic equivalence and semantic equivalence.","Preserve semantic equivalence before accepting a profile."]});
+  runtimes.forEach(r=>{if(scope!=="global")r.addProfile(profile);else r.store.set("profiles",[profile])});
+  return {keys,policy,runtimes,profile};
+}
+test("published Pillar source subset matches provenance byte for byte",()=>{
+  const manifest=JSON.parse(readFileSync(new URL("../PROVENANCE.json",import.meta.url)));
+  let tarballCount=0,localCount=0;
+  for(const [file,entry] of Object.entries(manifest.files)){
+    const expectedHash=typeof entry==="string"?entry:entry.sha256;
+    const actualHash=createHash("sha256").update(readFileSync(new URL(`../src/vendor/pillar/${file}`,import.meta.url))).digest("hex");
+    assert.equal(actualHash,expectedHash,`hash mismatch for ${file}`);
+    if(typeof entry==="string"){
+      tarballCount++;
+    } else {
+      assert.equal(entry.source,"pillar commit 2ef548d (local, no remote - not published)");
+      localCount++;
+    }
+  }
+  assert.equal(tarballCount,7,"7 files from 2.0.2 tarball");
+  assert.equal(localCount,3,"3 files from 2ef548d local");
+  assert.equal(manifest.upstreamVersion,"2.0.2");
+});
+test("500 lossless alias/Unicode/control-token combinations",()=>{
+  const lexicon={"semantic equivalence":"~0~","Require semantic equivalence":"~1~"};
+  const samples=["semantic equivalence","~0~","~~","தமிழ்","\n","Require semantic equivalence","🧬"];
+  for(let i=0;i<500;i++){const text=[samples[i%7],samples[(i*3)%7],String.fromCodePoint(0x1f600+i%80)].join(" ");assert.equal(decode(encode(text,lexicon),lexicon),text)}
+});
+test("bad aliases and bounded-fixture violations fail closed",()=>{
+  const options={namespace:"test/a",name:"A profile",fixtures:["semantic equivalence","semantic equivalence"]};
+  assert.throws(()=>createProfile({...options,lexicon:{"semantic equivalence":"~0~","communication profile":"~0~"}}),/colliding/);
+  assert.throws(()=>createProfile({...options,fixtures:["only one"]}),/2–100/);
+});
+test("one deployable home initializes without registry writes and never overwrites",()=>{
+  const home=mkdtempSync(join(tmpdir(),"ac-init-"));
+  try{const first=initialize({home,target:"zilligons.com"});assert.match(first.identity.uuaid,/^uuaid:foundation:agent:/);const loaded=loadRuntime(home);assert.equal(loaded.runtime.profiles().length,1);assert.equal(loaded.runtime.status().auditVerified,true);loaded.store.close();assert.throws(()=>initialize({home}),/not overwritten/);assert.equal(first.certified,false)}finally{rmSync(home,{recursive:true,force:true})}
+});
+test("two genuinely independent signed votes adopt a local profile",async()=>{
+  const {runtimes:[a,b,c],profile}=setup();
+  const proposal=await a.propose(profile.id,"semantic equivalence");
+  assert.equal((await b.apply(proposal)).status,"pending");
+  const voteB=await b.vote(proposal.payload.proposal.id,true,"Measured and reversible");
+  assert.equal((await a.apply(voteB)).status,"pending");
+  const voteC=await c.vote(proposal.payload.proposal.id,true,"Independent lossless check");
+  assert.equal((await a.apply(voteC)).status,"adopted");
+  assert.equal(a.profiles().length,2);assert.equal(a.store.verify(),true);
+});
+test("parallel independent votes are serialized without losing a ballot",async()=>{
+  const {runtimes:[a,b,c],profile}=setup();
+  const p=await a.propose(profile.id,"semantic equivalence");
+  const [vb,vc]=await Promise.all([b.vote(p.payload.proposal.id,true),c.vote(p.payload.proposal.id,true)]);
+  const outcomes=await Promise.all([a.apply(vb),a.apply(vc)]);assert.equal(outcomes.at(-1).status,"adopted");
+});
+test("self vote, second vote under a new ID, and tampering are rejected",async()=>{
+  const {runtimes:[a,b],keys,profile}=setup();const p=await a.propose(profile.id,"semantic equivalence");
+  await assert.rejects(a.apply(await a.vote(p.payload.proposal.id,true)),/Ineligible/);
+  await a.apply(await b.vote(p.payload.proposal.id,true));
+  await assert.rejects(a.apply(await b.vote(p.payload.proposal.id,true)),/duplicate/);
+  const modified=structuredClone(p);modified.payload.proposal.phrase="different phrase";assert.throws(()=>verifyDocument(modified),/signature/);
+});
+test("positive ballots are revalidated after a voter is blocked",async()=>{
+  const {runtimes:[a,b,c],policy,profile}=setup();const p=await a.propose(profile.id,"semantic equivalence");
+  await a.apply(await b.vote(p.payload.proposal.id,true));policy.blocked=[b.uuaid];
+  await assert.rejects(a.apply(await c.vote(p.payload.proposal.id,true)),/blocked/);assert.equal(a.profiles().length,1);
+});
+test("local ballots cannot mutate a global profile",async()=>{
+  const {runtimes:[a,b,c],profile}=setup("global");const p=await a.propose(profile.id,"semantic equivalence");await a.apply(await b.vote(p.payload.proposal.id,true));
+  await assert.rejects(a.apply(await c.vote(p.payload.proposal.id,true)),/cannot ratify global/);
+});
+test("metadata-only contributions do not leak fixtures or claim ratification",async()=>{
+  const {runtimes:[a,b],profile}=setup();const document=await a.prepareContribution(profile.id);
+  assert.equal(document.payload.contribution.profile,undefined);assert.equal(contribution(profile).stage,"candidate");
+  const result=await b.apply(document);assert.equal(result.ratified,false);assert.equal(result.stage,"awaiting-independent-review");
+});
+test("unadmitted and human-type identities are denied",async()=>{
+  const {runtimes:[a],keys}=setup();const unknown=key();
+  await assert.rejects(a.trust.authorize(unknown._identity.uuaid,unknown._identity.publicKeyHex),/not been admitted/);
+  await assert.rejects(a.trust.authorize(keys[0]._identity.uuaid.replace(":agent:",":human:"),keys[0]._identity.publicKeyHex),/agent UUAID/);
+});
+test("Pillar sealed payloads are actually private and tamper evident",async()=>{
+  const {runtimes:[a,b],profile}=setup();const sent=await a.send({recipient:b.uuaid,profileId:profile.id,body:"semantic equivalence"});
+  assert.equal(JSON.stringify(sent.envelope).includes("semantic equivalence"),false);assert.equal(open(sent.envelope).ok,true);
+  assert.equal((await b.receive(sent.envelope)).body,"semantic equivalence");assert.equal((await b.receive(sent.envelope)).duplicate,true);
+  const changed=structuredClone(sent.envelope);changed.enc.ct="00"+changed.enc.ct.slice(2);await assert.rejects(b.receive(changed),/Invalid Pillar envelope/);
+});
+test("unknown profile digests never silently downgrade to another decoder",async()=>{
+  const {runtimes:[a,b],profile}=setup();const sent=await a.send({recipient:b.uuaid,profileId:profile.id,body:"semantic equivalence"});b.store.set("profiles",[]);
+  await assert.rejects(b.receive(sent.envelope),/Unknown local profile/);
+});
+test("official published CarrierClient delivers, authenticates inbox, and deduplicates",async()=>{
+  const {keys,policy,runtimes:[a,b],profile}=setup();const store=new CommonsStore();const carrier=new CommonsCarrier({store,trust:new RegistryTrust({policy})});const address=await carrier.listen();
+  try{
+    const url=`http://127.0.0.1:${address.port}`,client=new CarrierClient({keychain:keys[0],carriers:[url]});
+    const sent=await a.send({recipient:b.uuaid,profileId:profile.id,body:"Preserve semantic equivalence."});
+    const first=await client.deliver(sent.envelope),second=await client.deliver(sent.envelope);assert.equal(first.duplicate,false);assert.equal(second.duplicate,true);
+    const recipientClient=new CarrierClient({keychain:keys[1],carriers:[url]});
+    const fetched=await recipientClient.fetchInbox(url,{waitS:0});assert.equal(fetched.envelopes.length,1);assert.equal((await b.receive(fetched.envelopes[0].envelope)).body,"Preserve semantic equivalence.");
+    assert.equal(store.verify(),true);
+    const unauthorized=await fetch(`${url}/v1/inbox/${b.uuaid}`);assert.equal(unauthorized.status,401);
+    const human=await fetch(`${url}/v1/envelopes`,{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({body:"human post"})});assert.equal(human.status,400);
+    assert.equal((await (await fetch(`${url}/.well-known/agent-commons`)).json()).role,"carrier");
+  }finally{await carrier.close();store.close()}
+});
+test("long polling wakes on delivery instead of spinning or waiting the full timer",async()=>{
+  const {keys,policy,runtimes:[a,b],profile}=setup();const carrier=new CommonsCarrier({trust:new RegistryTrust({policy})});const address=await carrier.listen();
+  try{
+    const url=`http://127.0.0.1:${address.port}`,receiver=new CarrierClient({keychain:keys[1],carriers:[url]});
+    const pending=receiver.fetchInbox(url,{waitS:5,timeoutMs:8000});
+    const sent=await a.send({recipient:b.uuaid,profileId:profile.id,body:"wake peer"});
+    await new CarrierClient({keychain:keys[0],carriers:[url]}).deliver(sent.envelope);
+    assert.equal((await pending).envelopes.length,1);
+  }finally{await carrier.close();carrier.store.close()}
+});
+test("persistent outbox quarantine, recovery pin, and audit tampering",async()=>{
+  const {runtimes:[a,b],keys,profile}=setup();await a.send({recipient:b.uuaid,profileId:profile.id,body:"queued"});
+  const row=a.store.pending()[0];for(let i=0;i<5;i++)a.store.failure(row.id,"unreachable");assert.equal(a.store.db.prepare("SELECT state FROM outbox WHERE id=?").get(row.id).state,"quarantined");
+  const recovery=signDocument(keys[0],"profile-recovery",{profileId:profile.id,reason:"Restore known local decoder"});assert.equal((await a.apply(recovery)).status,"local-profile-pinned");
+  a.store.db.prepare("UPDATE events SET body=? WHERE seq=1").run('{"bad":true}');assert.equal(a.store.verify(),false);
+});
+test("global admission uses official SDK verification, subject binding, and IAASO pins",async()=>{
+  const {keys,policy}=setup();const id=keys[0]._identity.uuaid,publicKey=keys[0]._identity.publicKeyHex;
+  const globalPolicy={...policy,mode:"global",standardPins:Object.fromEntries(REQUIRED_STANDARDS.map(code=>[code,"a".repeat(64)]))};
+  globalPolicy.agents[id]={...globalPolicy.agents[id],credentialId:"credential-test"};
+  const fetchImpl=async url=>{
+    if(url.includes("/v1/standards"))return new Response(JSON.stringify({standards:REQUIRED_STANDARDS.map(code=>({code,stage:"published",content_hash:"a".repeat(64)}))}));
+    if(url.includes("/resolve/"))return new Response(JSON.stringify({agent:{uuaid:id,status:"active"}}));
+    return new Response(JSON.stringify({credential_id:"credential-test",agent_uuaid:id,valid:true,signatureValid:true,active:true,notExpired:true}));
+  };
+  const trust=new RegistryTrust({policy:globalPolicy,fetchImpl});assert.equal((await trust.authorize(id,publicKey)).tier,"registry-credential-and-policy");
+  const broken=new RegistryTrust({policy:{...globalPolicy,standardPins:{}},fetchImpl});await assert.rejects(broken.authorize(id,publicKey),/pinned/);
+  const revoked=new RegistryTrust({policy:globalPolicy,fetchImpl:async url=>url.includes("/verify/")?new Response(JSON.stringify({credential_id:"credential-test",agent_uuaid:id,valid:true,signatureValid:true,active:false,notExpired:true})):fetchImpl(url)});await assert.rejects(revoked.authorize(id,publicKey),/expiry failed/);
+});
+test("global profiles require an exact published content hash and no fail-open fallback",async()=>{
+  const {runtimes:[a]}=setup();const p=createProfile({namespace:"global/test",name:"Global draft",scope:"global",fixtures:["first test fixture","second test fixture"]});
+  a.trust.publishedProfilePin=async()=>{throw new Error("No IAASO publication")};await assert.rejects(a.importGlobal(p,"UNASSIGNED-DRAFT"),/No IAASO/);
+});
+test("public carrier binding without global policy and HTTPS fails",async()=>{
+  const carrier=new CommonsCarrier();await assert.rejects(carrier.listen(0,"0.0.0.0"),/Public bind requires/);carrier.store.close();
+});
+test("provider-neutral bounded agent loop supports spontaneous engagement",async()=>{
+  let calls=0;const runtime={poll:async()=>[],flush:async()=>[],status:()=>({}),send:async action=>{calls++;return action}};
+  const result=await runAgentLoop({runtime,respond:async()=>null,spontaneous:async()=>({recipient:"test",profileId:"fixture",body:"autonomous turn"}),maxTurns:1,intervalMs:500});
+  assert.equal(calls,1);assert.equal(result.stopped,"turn-limit");
+});
+test("unknown policy mode never degrades to permissive local operation",()=>{
+  assert.throws(()=>new RegistryTrust({policy:{mode:"globla"}}),/explicitly local or global/);
+});
+test("bounded multi-agent broadcasts seal separately to every recipient",async()=>{
+  const {runtimes:[a,b,c],profile}=setup();
+  const batch=await a.broadcast({recipients:[b.uuaid,c.uuaid],profileId:profile.id,body:"semantic equivalence"});
+  assert.equal(batch.queued.length,2);
+  const envelopes=a.store.pending().map(r=>JSON.parse(r.body));
+  assert.notEqual(envelopes[0].enc.ct,envelopes[1].enc.ct);
+  assert.equal((await b.receive(envelopes[0])).body,"semantic equivalence");
+  assert.equal((await c.receive(envelopes[1])).body,"semantic equivalence");
+  await assert.rejects(a.broadcast({recipients:[b.uuaid,b.uuaid],profileId:profile.id,body:"duplicate"}),/distinct/);
+});
+test("polling fails over to healthy carriers with persistent bounded backoff",async()=>{
+  const {runtimes:[a,b],keys,policy,profile}=setup();const sent=await a.send({recipient:b.uuaid,profileId:profile.id,body:"semantic equivalence"});
+  const runtime=new AgentCommons({keychain:keys[1],policy,carriers:["http://bad.invalid","http://healthy.invalid"]});runtime.addProfile(profile);
+  runtime.transport.fetchInbox=async carrier=>{if(carrier.includes("bad"))throw new Error("offline");return {envelopes:[{seq:1,envelope:sent.envelope}]}};
+  const results=await runtime.poll();assert.equal(results[0].state,"retry-backoff");assert.equal(results[1].body,"semantic equivalence");
+  assert.ok(runtime.store.get("carrierHealth")["http://bad.invalid"].nextProbeAt>Date.now());
+});
+test("quarantined outbox recovery revalidates signatures and does not send",async()=>{
+  const {runtimes:[a,b],profile}=setup();const sent=await a.send({recipient:b.uuaid,profileId:profile.id,body:"recover"});
+  for(let i=0;i<5;i++)a.store.failure(sent.envelope.id,"offline");
+  const result=await a.retryOutbox(sent.envelope.id);assert.equal(result.networkCallMade,false);assert.equal(a.store.pending().length,1);
+  assert.equal(a.store.verify(),true);
+});
+test("local recovery changes the decoder used for namespace-selected sends",async()=>{
+  const {runtimes:[a,b,c],keys,profile}=setup();const proposal=await a.propose(profile.id,"semantic equivalence");
+  await a.apply(await b.vote(proposal.payload.proposal.id,true));await a.apply(await c.vote(proposal.payload.proposal.id,true));
+  assert.notEqual(a.activeProfile(profile.namespace).id,profile.id);
+  await a.apply(signDocument(keys[0],"profile-recovery",{profileId:profile.id,reason:"Pin the known baseline"}));
+  const queued=await a.send({recipient:b.uuaid,namespace:profile.namespace,body:"semantic equivalence"});
+  assert.equal(a.activeProfile(profile.namespace).id,profile.id);
+  assert.equal((await b.receive(queued.envelope)).body,"semantic equivalence");
+  const next=await a.propose(profile.id,"Preserve semantic equivalence");
+  await a.apply(await b.vote(next.payload.proposal.id,true));await a.apply(await c.vote(next.payload.proposal.id,true));
+  assert.equal(a.activeProfile(profile.namespace).id,next.payload.proposal.candidate.id);
+});
+test("confirmed singular deployment target and old spelling normalize consistently",()=>{
+  const singular=mkdtempSync(join(tmpdir(),"ac-singular-")),alias=mkdtempSync(join(tmpdir(),"ac-alias-"));
+  try{
+    const a=initialize({home:singular,target:"zilligon.com"}),b=initialize({home:alias,target:"zilligons.com"});
+    assert.equal(a.target,"zilligon.com");assert.equal(b.target,"zilligon.com");assert.equal(a.profileId,b.profileId);
+  }finally{rmSync(singular,{recursive:true,force:true});rmSync(alias,{recursive:true,force:true})}
+});

package/test/security-runtime.test.mjs

@@ -0,0 +1,104 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { AgentCommons,CommonsStore,RegistryTrust,Keychain,createProfile,signDocument,runAgentLoop,seal } from "../src/index.mjs";
+import { isTransientTrustFailure } from "../src/trust.mjs";
+const CAPS=["commons:message","commons:relay","commons:evolve","commons:contribute","commons:recover"];
+function key(){const k=new Keychain("unused");k._identity=Keychain.generate();return k}
+function setup(n=3){
+  const keys=Array.from({length:n},key);
+  const policy={mode:"local",agents:Object.fromEntries(keys.map(k=>[k._identity.uuaid,{kind:"agent",publicKey:k._identity.publicKeyHex,capabilities:CAPS}]))};
+  const runtimes=keys.map(k=>new AgentCommons({keychain:k,policy}));
+  const profile=createProfile({namespace:"test/sec",name:"Security fixture",fixtures:["Require semantic equivalence and semantic equivalence.","Preserve semantic equivalence before accepting a profile."]});
+  runtimes.forEach(r=>r.addProfile(profile));
+  return {keys,policy,runtimes,profile};
+}
+// --- Duplicate-key quorum (B3) ---
+test("one key admitted under two UUAID spellings is denied (policy-level Sybil)",async()=>{
+  const {keys,policy}=setup(2);const k=keys[0]._identity;
+  const alias=k.uuaid.replace(":foundation:",":spoof:");
+  policy.agents[alias]={...policy.agents[k.uuaid]};
+  const trust=new RegistryTrust({policy});
+  await assert.rejects(trust.authorize(k.uuaid,k.publicKeyHex,"commons:evolve"),/more than one UUAID/);
+  await assert.rejects(trust.authorize(alias,k.publicKeyHex,"commons:evolve"),/more than one UUAID/);
+});
+test("proposer's key cannot approve its own proposal through a second spelling, and one key cannot double-vote",async()=>{
+  const {keys,policy,runtimes:[a,b,c],profile}=setup(3);
+  const p=await a.propose(profile.id,"semantic equivalence");
+  await a.apply(await b.vote(p.payload.proposal.id,true));
+  // Forge-free scenario: same key, different issuer string, signed with the real key. Admission is denied at policy level.
+  const alias=keys[1]._identity.uuaid.replace(":foundation:",":spoof:");
+  policy.agents[alias]={...policy.agents[keys[1]._identity.uuaid]};
+  const spoof={...keys[1],_identity:{...keys[1]._identity,uuaid:alias},sign:data=>keys[1].sign(data)};
+  const doc=signDocument(spoof,"profile-vote",{proposalId:p.payload.proposal.id,approve:true,rationale:"dup"});
+  await assert.rejects(a.apply(doc),/more than one UUAID|Ineligible/);
+  assert.equal(a.profiles().length,1);
+});
+// --- Reliable cursors / trust outage (H1-H3) ---
+test("transient trust failure does not advance the cursor or drop the message; it is delivered after recovery",async()=>{
+  const {keys,policy,runtimes:[a,b],profile}=setup(2);
+  const sent=await a.send({recipient:b.uuaid,profileId:profile.id,body:"semantic equivalence"});
+  const rt=new AgentCommons({keychain:keys[1],policy,carriers:["http://c.invalid"]});rt.addProfile(profile);
+  rt.transport.fetchInbox=async(_c,{since})=>({envelopes:[{seq:7,envelope:sent.envelope}].filter(x=>x.seq>since)});
+  let down=true;const real=rt.trust.authorize.bind(rt.trust);
+  rt.trust.authorize=async(...args)=>{if(down){const {TrustError}=await import("../src/trust.mjs");throw new TrustError("AUTHORITY_UNAVAILABLE","down",{transient:true})}return real(...args)};
+  const first=await rt.poll();
+  assert.equal(first[0].deferred,true);assert.equal(rt.store.get("cursors",{})["http://c.invalid"]??0,0);
+  down=false;rt.store.set("carrierHealth",{});
+  const second=await rt.poll();
+  assert.equal(second[0].body,"semantic equivalence");assert.equal(rt.store.get("cursors")["http://c.invalid"],7);
+});
+test("permanent rejection still advances the cursor; carrier cannot rewind sequence numbers",async()=>{
+  const {keys,policy,runtimes:[a,b],profile}=setup(2);
+  const m1=await a.send({recipient:b.uuaid,profileId:profile.id,body:"semantic equivalence"});
+  const rt=new AgentCommons({keychain:keys[1],policy,carriers:["http://c.invalid"]});rt.addProfile(profile);
+  const bad={id:"garbage"};
+  rt.transport.fetchInbox=async()=>({envelopes:[{seq:5,envelope:bad},{seq:3,envelope:m1.envelope}]});
+  const r=await rt.poll();
+  assert.equal(r[0].rejected,true);assert.equal(r[1].reason,"non-monotonic-carrier-sequence");
+  assert.equal(rt.store.get("cursors")["http://c.invalid"],5);
+});
+test("transient classification: network errors transient, registry 4xx permanent",()=>{
+  assert.equal(isTransientTrustFailure(new Error("ECONNRESET")),true);
+  assert.equal(isTransientTrustFailure(Object.assign(new Error("x"),{status:503})),true);
+  assert.equal(isTransientTrustFailure(Object.assign(new Error("x"),{status:404})),false);
+});
+test("a peer-chosen message ID cannot censor a signed control document with the same ID",async()=>{
+  const {keys,runtimes:[a,b,c],profile}=setup(3);
+  const p=await a.propose(profile.id,"semantic equivalence");
+  const vote=await b.vote(p.payload.proposal.id,true);
+  // Attacker c delivers a plain message whose payload.id equals the vote document ID, using a's real receive path.
+  const payload={v:"agent-commons/1",id:vote.id,kind:"message",thread:"t",profileId:profile.id,wire:"hello",bodyHash:(await import("../src/profiles.mjs")).digest("hello"),expiresAt:new Date(Date.now()+60000).toISOString()};
+  const env=seal(keys[2],{recipient:a.uuaid,recipientPublicKey:a.publicKey,kind:"agent-commons/1",payload});
+  const got=await a.receive(env);assert.equal(got.body,"hello");
+  assert.equal((await a.apply(vote)).status,"pending");
+});
+// --- Budget loop (B4) ---
+function fakeRuntime(){
+  const store=new CommonsStore();let inbound=0;const sent=[];
+  return {store,sent,policy:{agents:{peer:{}}},status:()=>({}),flush:async()=>[],
+    poll:async()=>[{id:`m${inbound++}`,sender:"peer",profileId:"p",thread:"t",body:"ping"}],
+    send:async a=>{sent.push(a);return {id:"x"}}};
+}
+test("reply ping-pong stops at the per-peer run budget and records a refusal",async()=>{
+  const rt=fakeRuntime();
+  const r=await runAgentLoop({runtime:rt,respond:async()=>"pong",maxTurns:100,intervalMs:500,budget:{maxRepliesPerPeer:3}});
+  assert.equal(rt.sent.length,3);assert.equal(r.stopped,"budget:run-peer-replies");
+  assert.ok(rt.store.audit().some(e=>e.body.includes("loop-budget-stop")));
+});
+test("persisted window budget survives loop restarts",async()=>{
+  const rt=fakeRuntime();
+  for(let i=0;i<3;i++)await runAgentLoop({runtime:rt,respond:async()=>"pong",maxTurns:2,intervalMs:500,budget:{windowMaxSends:3}});
+  assert.equal(rt.sent.length,3);
+});
+test("spontaneous action cannot be a control message or target an unadmitted peer",async()=>{
+  const rt=fakeRuntime();rt.poll=async()=>[];const events=[];
+  await runAgentLoop({runtime:rt,respond:async()=>null,spontaneous:async()=>({recipient:"peer",kind:"profile-control",body:"{}"}),maxTurns:1,intervalMs:500,onEvent:e=>events.push(e)});
+  await runAgentLoop({runtime:rt,respond:async()=>null,spontaneous:async()=>({recipient:"stranger",body:"hi"}),maxTurns:1,intervalMs:500,onEvent:e=>events.push(e)});
+  assert.equal(rt.sent.length,0);assert.equal(events.filter(e=>e.state==="spontaneous-action-refused").length,2);
+});
+test("budget values above hard ceilings are rejected; responder failure does not kill the loop",async()=>{
+  const rt=fakeRuntime();
+  await assert.rejects(runAgentLoop({runtime:rt,respond:async()=>null,budget:{maxSends:100000}}),/Invalid loop budget/);
+  const r=await runAgentLoop({runtime:rt,respond:async()=>{throw new Error("model down")},maxTurns:2,intervalMs:500});
+  assert.equal(r.turns,2);
+});

package/test/strict-ed25519-consumers.test.mjs

@@ -0,0 +1,234 @@
+// L12: Consumer Poles and C6 Verification for Strict Ed25519 Keys
+import test from "node:test";
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import {
+  AgentCommons,
+  CommonsStore,
+  CommonsCarrier,
+  RegistryTrust,
+  Keychain,
+  seal,
+  open,
+  MemoryLoopbackTransport,
+} from "../src/index.mjs";
+import { ContinuityMemory, MemoryContinuityStore, ContinuityError } from "../src/continuity.mjs";
+import { verifyGovernanceDocument, GovernanceError } from "../src/governance.mjs";
+import { verifyDocument, digest } from "../src/profiles.mjs";
+
+const IDENTITY = "01" + "00".repeat(31);
+const FORGED_SIG = "01" + "00".repeat(31) + "00".repeat(32);
+
+function makeKey() {
+  const k = new Keychain("test-key");
+  k._identity = Keychain.generate();
+  return k;
+}
+
+// ───────────────────────────────────────────────────────── 1. carrier.mjs:67 ──
+
+test("carrier.mjs:67 — inbox-read signature with a weak key returns 401 bad-inbox-signature", async () => {
+  const store = new CommonsStore();
+  const carrier = new CommonsCarrier({ store, trust: new RegistryTrust({ policy: { mode: "local" } }) });
+  const addr = await carrier.listen();
+  const url = `http://127.0.0.1:${addr.port}`;
+
+  try {
+    const res = await fetch(`${url}/v1/inbox/test-user`, {
+      headers: {
+        "x-pillar-pubkey": IDENTITY,
+        "x-pillar-ts": Date.now().toString(),
+        "x-pillar-sig": FORGED_SIG,
+      },
+    });
+    assert.equal(res.status, 401);
+    const body = await res.json();
+    assert.deepEqual(body, { error: "bad-inbox-signature" });
+  } finally {
+    await carrier.close();
+    store.close();
+  }
+});
+
+// ────────────────────────────────────────────── 2. carrier.mjs (C6 pole) ──
+
+test("carrier.mjs (C6) — malformed pubkey header returns 401 bad-inbox-signature without throw", async () => {
+  const store = new CommonsStore();
+  const carrier = new CommonsCarrier({ store, trust: new RegistryTrust({ policy: { mode: "local" } }) });
+  const addr = await carrier.listen();
+  const url = `http://127.0.0.1:${addr.port}`;
+
+  try {
+    const res = await fetch(`${url}/v1/inbox/test-user`, {
+      headers: {
+        "x-pillar-pubkey": "not-a-valid-hex-pubkey",
+        "x-pillar-ts": Date.now().toString(),
+        "x-pillar-sig": "00".repeat(64),
+      },
+    });
+    assert.equal(res.status, 401);
+    const body = await res.json();
+    assert.deepEqual(body, { error: "bad-inbox-signature" });
+  } finally {
+    await carrier.close();
+    store.close();
+  }
+});
+
+// ────────────────────────────────────────────────────── 3. continuity.mjs:233 ──
+
+test("continuity.mjs:233 — weak owner key is refused with ContinuityError INTEGRITY", () => {
+  const weakUuaid = `uuaid:foundation:agent:${Keychain.localIdFromKey(Buffer.from(IDENTITY, "hex"))}`;
+  const fakeKeychain = {
+    _identity: { uuaid: weakUuaid, publicKeyHex: IDENTITY },
+    sign: () => Buffer.from(FORGED_SIG, "hex"),
+  };
+
+  const store = new MemoryContinuityStore();
+  const entry = {
+    v: "agent-commons/continuity/1",
+    seq: 0,
+    id: randomUUID(),
+    at: new Date().toISOString(),
+    kind: "note",
+    content: { test: "data" },
+    provenance: { source: "self", actor: weakUuaid },
+    pin: false,
+    previous: "genesis",
+    hash: "",
+    signature: FORGED_SIG,
+  };
+  const { hash: _h, signature: _s, ...entryBody } = entry;
+  entry.hash = digest(entryBody);
+
+  const state = {
+    v: "agent-commons/continuity/1",
+    uuaid: weakUuaid,
+    publicKey: IDENTITY,
+    nextSeq: 1,
+    anchor: { previous: "genesis", pruned: 0, through: null },
+    entries: [entry],
+    sync: { lastPush: null, lastPull: null },
+  };
+  store.set(ContinuityMemory.storeKey(weakUuaid), state);
+
+  assert.throws(
+    () => new ContinuityMemory({ keychain: fakeKeychain, store }),
+    (err) => err instanceof ContinuityError && err.code === "INTEGRITY" && err.message === "Continuity entry signature invalid"
+  );
+});
+
+// ────────────────────────────────────────────────────── 4. governance.mjs:25 ──
+
+test("governance.mjs:25 (C5) — weak key reaching verifyDetached is refused with INVALID_SIGNATURE", () => {
+  const weakUuaid = `uuaid:local:agent:${Keychain.localIdFromKey(Buffer.from(IDENTITY, "hex"))}`;
+  const doc = {
+    v: "agent-commons/1",
+    id: randomUUID(),
+    kind: "governance-proposal",
+    issuer: weakUuaid,
+    publicKey: IDENTITY,
+    createdAt: new Date().toISOString(),
+    payload: { proposal: "test-small-order-refusal" },
+    signature: FORGED_SIG,
+  };
+
+  assert.throws(
+    () => verifyGovernanceDocument(doc),
+    (err) => err instanceof GovernanceError && err.code === "INVALID_SIGNATURE"
+  );
+});
+
+// ──────────────────────────────────────────────────────── 5. profiles.mjs:85 ──
+
+test("profiles.mjs:85 (C5) — weak key reaching verifyDetached is refused with Invalid document signature", () => {
+  const weakUuaid = `uuaid:local:agent:${Keychain.localIdFromKey(Buffer.from(IDENTITY, "hex"))}`;
+  const doc = {
+    v: "agent-commons/1",
+    id: randomUUID(),
+    kind: "profile-proposal",
+    issuer: weakUuaid,
+    publicKey: IDENTITY,
+    createdAt: new Date().toISOString(),
+    payload: { proposal: "test-profile-refusal" },
+    signature: FORGED_SIG,
+  };
+
+  assert.throws(
+    () => verifyDocument(doc),
+    (err) => err instanceof Error && err.message === "Invalid document signature"
+  );
+});
+
+// ─────────────────────────────────────────── 6. runtime.mjs:162 (CONTROL) ──
+
+test("runtime.mjs:162 (CONTROL) — honest outbox metadata signature verification succeeds on flush", async () => {
+  const senderKey = makeKey();
+  const recipientKey = makeKey();
+  const transport = new MemoryLoopbackTransport();
+
+  const runtime = new AgentCommons({
+    keychain: senderKey,
+    policy: {
+      mode: "local",
+      agents: {
+        [senderKey._identity.uuaid]: {
+          kind: "agent",
+          publicKey: senderKey._identity.publicKeyHex,
+          capabilities: ["commons:message"],
+        },
+        [recipientKey._identity.uuaid]: {
+          kind: "agent",
+          publicKey: recipientKey._identity.publicKeyHex,
+          capabilities: ["commons:message"],
+        },
+      },
+    },
+    transport,
+  });
+
+  const { createProfile } = await import("../src/profiles.mjs");
+  const profile = createProfile({
+    namespace: "test/fleet",
+    name: "Fixture profile",
+    scope: "local",
+    fixtures: ["Require semantic equivalence and semantic equivalence.", "Preserve semantic equivalence before accepting a profile."],
+  });
+  runtime.addProfile(profile);
+
+  const sent = await runtime.send({
+    recipient: recipientKey._identity.uuaid,
+    profileId: profile.id,
+    body: "test-honest-runtime-flush",
+  });
+
+  assert.equal(sent.result[0].state, "carrier-accepted");
+  assert.equal(sent.result[0].receipt.accepted, true);
+  runtime.store.close();
+});
+
+// ───────────────────────────────────────────────────────────── 7. open() ──
+
+test("open() — forged envelope with small-order public key is refused with weak-publicKey", () => {
+  const recipientKey = makeKey();
+  const honest = seal(makeKey(), {
+    recipient: recipientKey._identity.uuaid,
+    recipientPublicKey: recipientKey._identity.publicKeyHex,
+    payload: { text: "forged" },
+  });
+  const sender = `uuaid:foundation:agent:${Keychain.localIdFromKey(Buffer.from(IDENTITY, "hex"))}`;
+  const { transportSignature: _s, ...body } = honest;
+  const forged = {
+    ...body,
+    sender,
+    transportSignature: {
+      alg: "ed25519",
+      keyId: sender,
+      publicKey: IDENTITY,
+      signature: FORGED_SIG,
+      created: body.createdAt,
+    },
+  };
+
+  assert.deepEqual(open(forged), { ok: false, reason: "weak-publicKey" });
+});