From 86d57ec9ae00a1fcedb32b90d3329dc2065af531 Mon Sep 17 00:00:00 2001
From: Richard Clark <endami@users.noreply.github.com>
Date: Tue, 22 Sep 2026 14:17:06 -0400
Subject: [PATCH 01/13] Fix conversation failure handling and confirmed
 delivery memories

---
 app/page.tsx                |  2 +-
 core/conversation-store.ts  | 19 ++++++++++++++++-
 core/conversation.ts        | 31 +++++++++++++---------------
 scripts/test-core.mjs       |  4 ++--
 tests/conversation.test.cjs | 41 +++++++++++++++++++++++++++++++++++++
 5 files changed, 76 insertions(+), 21 deletions(-)
 create mode 100644 tests/conversation.test.cjs

diff --git a/app/page.tsx b/app/page.tsx
index 90d8ad8..5a4039c 100644
--- a/app/page.tsx
+++ b/app/page.tsx
@@ -61,7 +61,7 @@ function CreateBot({state,act,busy,close}:any){const [name,setName]=useState('')
 function RecipeEditor({recipe,act,busy,close}:any){const [r,setR]=useState<Recipe>(recipe??{name:'',description:'',tags:['Curious'],sociability:50,aggression:20,curiosity:70,economy:30,activities:['explore','quest']});const [tags,setTags]=useState(r.tags.join(', '));return <form onSubmit={async e=>{e.preventDefault();try{await act({type:'saveRecipe',recipe:{...r,tags:tags.split(',').map(t=>t.trim()).filter(Boolean)}});toast.success('Recipe saved');close();}catch{}}}><div className="form-grid"><label className="field full">Recipe name<Input required minLength={2} maxLength={80} value={r.name} onChange={e=>setR({...r,name:e.target.value})}/></label><label className="field full">Personality description<textarea maxLength={500} value={r.description} onChange={e=>setR({...r,description:e.target.value})}/></label><label className="field full">Tags, separated by commas<Input value={tags} onChange={e=>setTags(e.target.value)}/></label></div><div className="section-grid" style={{gap:25,marginTop:20}}><div>{(['sociability','aggression','curiosity','economy'] as const).map(key=><div className="range-row" key={key}><div className="range-label"><span style={{textTransform:'capitalize'}}>{key}</span><span>{r[key]}</span></div><Slider aria-label={key} min={0} max={100} step={1} value={[r[key]]} onValueChange={v=>setR({...r,[key]:v[0]})}/></div>)}</div><div><h3 style={{margin:'15px 0'}}>Preferred activities</h3><div className="choices">{ACTIVITIES.map(a=><label className="choice-row" key={a}><Checkbox checked={r.activities.includes(a)} onCheckedChange={v=>setR({...r,activities:v?[...r.activities,a]:r.activities.filter(x=>x!==a)})}/>{a}</label>)}</div></div></div><div className="form-footer">{recipe&&<Button type="button" variant="outline" disabled={busy} onClick={async()=>{try{const {id,version,...copy}=r;void id;void version;await act({type:'saveRecipe',recipe:{...copy,name:`${copy.name} copy`.slice(0,80)}});close();}catch{}}}><Copy size={15}/>Duplicate</Button>}<Button disabled={busy||!r.activities.length}>Save recipe</Button></div></form>}
 function BotProfile({bot:b,state,act,busy,perform,confirm}:any){const [memory,setMemory]=useState(''),[importance,setImportance]=useState(7),[target,setTarget]=useState(state.bots.find((x:Bot)=>x.id!==b.id)?.id??''),[affinity,setAffinity]=useState(40),[note,setNote]=useState(''),[recipeId,setRecipeId]=useState(b.recipeId);const actions=b.status==='online'?['pause','despawn']:b.status==='paused'?['resume','despawn']:b.status==='offline'?['spawn','retire']:[];return <><div className="detail-header"><Avatar bot={b}/><div><h2>{b.name}</h2><p className="subtitle">Level {b.level} {b.race} {b.role}</p></div><span className={`tag ${b.status}`} style={{marginLeft:'auto'}}>{b.status}</span></div><div className="actions">{actions.map(a=><Button key={a} size="sm" variant={a==='spawn'?'default':'outline'} disabled={busy} onClick={()=>a==='retire'?confirm({title:`Retire ${b.name}?`,description:'The identity and memories remain in your realm, but this bot cannot spawn again in this prototype.',action:{type:'lifecycle',botId:b.id,action:a}}):perform({type:'lifecycle',botId:b.id,action:a})}>{a==='pause'?<Pause size={14}/>:a==='spawn'||a==='resume'?<Play size={14}/>:null}{a.charAt(0).toUpperCase()+a.slice(1)}</Button>)}<Button size="sm" disabled={busy||b.status!=='online'} onClick={()=>perform({type:'think',botId:b.id})}><Brain size={15}/>{busy?'Working…':'Run decision'}</Button></div><Tabs defaultValue="identity" className="mt-6"><TabsList className="w-full"><TabsTrigger value="identity">Identity</TabsTrigger><TabsTrigger value="memory">Memory</TabsTrigger><TabsTrigger value="bonds">Relationships</TabsTrigger></TabsList><TabsContent value="identity"><div className="detail-block"><h3>Current goal</h3><p>{b.goal}</p><p style={{marginTop:12,display:'flex',gap:7,alignItems:'center'}}><MapPin size={15}/>{b.zone}</p></div><div className="detail-block"><h3>{b.personality.name} <small>v{b.recipeVersion}</small></h3><p>{b.personality.description}</p><div className="actions" style={{marginTop:12}}>{b.personality.tags.map((t:string)=><span className="tag" key={t}>{t}</span>)}</div><div className="field" style={{marginTop:20}}><Choice label="Apply recipe" value={recipeId} onChange={setRecipeId} items={state.recipes.map((r:Recipe)=>({value:r.id,label:`${r.name} · v${r.version}`}))}/><Button variant="outline" disabled={busy} onClick={()=>perform({type:'applyRecipe',botId:b.id,recipeId})}>Apply current recipe version</Button></div></div><div className="detail-block"><h3>Latest decision</h3><p>{b.lastDecision?`${b.lastDecision.action}: ${b.lastDecision.reason}`:'No decisions yet. Run a decision while this bot is online.'}</p><small>{b.decisions} decisions acknowledged</small></div></TabsContent><TabsContent value="memory"><form className="detail-block" onSubmit={async e=>{e.preventDefault();try{await act({type:'memory',botId:b.id,text:memory,importance});setMemory('');}catch{}}}><label className="field">Add a memory<textarea required value={memory} maxLength={1000} onChange={e=>setMemory(e.target.value)} placeholder="What should this character remember?"/></label><div className="range-row"><div className="range-label">Importance <span>{importance}/10</span></div><Slider aria-label="Memory importance" min={1} max={10} value={[importance]} onValueChange={v=>setImportance(v[0])}/></div><Button disabled={busy}>Save memory</Button></form>{[...b.memories].reverse().map((m:any)=><div className="memory" key={m.id}><p className="list-muted">{m.text}</p><small>{m.source} · Importance {m.importance}/10 · {new Date(m.at).toLocaleDateString()}</small></div>)}</TabsContent><TabsContent value="bonds"><p className="fineprint">Bonds are directional. One character’s trust does not imply the other’s.</p><form className="detail-block" onSubmit={async e=>{e.preventDefault();try{await act({type:'relationship',botId:b.id,targetId:target,affinity,note});setNote('');}catch{}}}><div className="field"><label>Other character</label><Choice label="Other character" value={target} onChange={setTarget} items={state.bots.filter((x:Bot)=>x.id!==b.id).map((x:Bot)=>({value:x.id,label:x.name}))}/></div><div className="range-row"><div className="range-label">Affinity <span>{affinity>0?'+':''}{affinity}</span></div><Slider aria-label="Affinity" min={-100} max={100} value={[affinity]} onValueChange={v=>setAffinity(v[0])}/></div><label className="field">Why this bond exists<textarea required maxLength={300} value={note} onChange={e=>setNote(e.target.value)}/></label><Button className="mt-4" disabled={busy||!target}>Save relationship</Button></form>{b.relationships.map((r:any)=><div className="memory" key={r.targetId}><h3>{state.bots.find((x:Bot)=>x.id===r.targetId)?.name} <span className="tag">{r.affinity>0?'+':''}{r.affinity}</span></h3><p className="list-muted">{r.note}</p></div>)}</TabsContent></Tabs></>}
 function WorldMonitor({state,monitor,capabilities,openBot}:any){
- const living=state.bots.filter((b:Bot)=>b.status!=='dead'&&b.status!=='retired');
+ const living:Bot[]=state.bots.filter((b:Bot)=>b.status!=='dead'&&b.status!=='retired');
  const active=living.filter((b:Bot)=>b.status==='online');
  const managed=living.filter((b:Bot)=>b.autonomy?.managed===true);
  const foreground=living.filter((b:Bot)=>b.simulationBand==='foreground');
diff --git a/core/conversation-store.ts b/core/conversation-store.ts
index 690806a..746bcc9 100644
--- a/core/conversation-store.ts
+++ b/core/conversation-store.ts
@@ -10,7 +10,7 @@ export type ConversationRequest={
  receiver:string;
  selectedPlayer:string;
  nearbyBots:string[];
- status:'pending'|'processing'|'completed'|'failed';
+ status:'pending'|'processing'|'awaiting_delivery'|'completed'|'failed';
  attempts:number;
 };
 
@@ -124,3 +124,20 @@ export async function cleanupConversations(db:D1Database){
   WHERE status IN ('completed','failed') AND completed_at IS NOT NULL AND completed_at<?`)
   .bind(before).run();
 }
+
+export async function awaitDelivery(db:D1Database,request:ConversationRequest,botId:string,reply:string,commandId:string){
+ await db.prepare("UPDATE conversation_requests SET status='awaiting_delivery',result=? WHERE id=?")
+  .bind(JSON.stringify({request,botId,reply,commandId}),request.id).run();
+}
+
+export async function pendingDeliveries(db:D1Database){
+ await ensure(db);
+ const rows=await db.prepare("SELECT result FROM conversation_requests WHERE status='awaiting_delivery' ORDER BY created_at LIMIT 50").all<{result:string}>();
+ const deliveries=[];
+ for(const row of rows.results){
+  const delivery=JSON.parse(row.result) as {request:ConversationRequest;botId:string;reply:string;commandId:string};
+  const command=await db.prepare('SELECT status,error FROM ale_commands WHERE id=?').bind(delivery.commandId).first<{status:string;error:string|null}>();
+  deliveries.push({...delivery,status:command?.status??'pending',error:command?.error});
+ }
+ return deliveries;
+}
diff --git a/core/conversation.ts b/core/conversation.ts
index 73cf667..8d59f70 100644
--- a/core/conversation.ts
+++ b/core/conversation.ts
@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { queueAleCommand } from './ale-store';
 import { luaString } from './ale';
-import { cleanupConversations,completeConversation,failConversation,leaseConversation,type ConversationRequest } from './conversation-store';
+import { cleanupConversations,completeConversation,failConversation,leaseConversation,awaitDelivery,pendingDeliveries,type ConversationRequest } from './conversation-store';
 import type { Bot,RealmEvent,RuntimeConfig,State,StateStore } from './types';
 
 const replySchema=z.object({reply:z.string().min(1).max(500)}).strict();
@@ -54,14 +54,8 @@ function chooseTarget(state:State,request:ConversationRequest){
  return undefined;
 }
 
-function fallbackReply(bot:Bot,request:ConversationRequest){
- if(/\b(hello|hi|hey|yo)\b/i.test(request.message))return `Hello, ${request.speakerName}.`;
- if(request.message.includes('?'))return `I'm not sure, ${request.speakerName}. We can figure it out together.`;
- return `I hear you, ${request.speakerName}.`;
-}
-
 async function modelReply(bot:Bot,request:ConversationRequest,state:State,config:RuntimeConfig){
- if(!config.LLM_URL||state.settings.provider==='deterministic')return fallbackReply(bot,request);
+ if(!config.LLM_URL||state.settings.provider==='deterministic')throw new Error('Conversation model is not configured; no canned reply was sent');
 
  const brains=state.settings.brains;
  const hero=bot.tier==='hero';
@@ -133,8 +127,9 @@ async function remember(store:StateStore,botId:string,request:ConversationReques
   const revision=state.revision;
   const bot=state.bots.find(x=>x.id===botId);
   if(!bot)return;
+  if(bot.memories.some(memory=>memory.id===request.id))return;
   bot.memories.push({
-   id:crypto.randomUUID(),
+   id:request.id,
    text:`${request.speakerName} said: "${request.message.slice(0,180)}" I replied: "${reply.slice(0,180)}"`,
    importance:request.channel==='whisper'?7:6,
    source:'observation',
@@ -153,6 +148,14 @@ async function remember(store:StateStore,botId:string,request:ConversationReques
 }
 
 export async function runConversationTick(store:StateStore,db:D1Database,config:RuntimeConfig){
+ for(const delivery of await pendingDeliveries(db)){
+  if(delivery.status==='completed'){
+   await remember(store,delivery.botId,delivery.request,delivery.reply);
+   await completeConversation(db,delivery.request.id,JSON.stringify({commandId:delivery.commandId,delivered:true}));
+  }else if(delivery.status==='failed'){
+   await failConversation(db,delivery.request.id,delivery.error||'Game rejected conversation delivery');
+  }
+ }
  const request=await leaseConversation(db);
  if(!request)return {ok:true,ran:false,reason:'No player conversation waiting'};
 
@@ -164,18 +167,12 @@ export async function runConversationTick(store:StateStore,db:D1Database,config:
    return {ok:true,ran:false,reason:'No addressed managed Playerbot matched',speaker:request.speakerName};
   }
 
-  let reply:string;
-  try{
-   reply=await modelReply(bot,request,state,config);
-  }catch{
-   reply=fallbackReply(bot,request);
-  }
+  let reply=await modelReply(bot,request,state,config);
   reply=cleanReply(reply);
   if(!reply)throw new Error('Conversation reply was empty');
 
   const command=await queueAleCommand(db,compileReply(bot.name,request.speakerName,reply,request.channel));
-  await remember(store,bot.id,request,reply);
-  await completeConversation(db,request.id,JSON.stringify({bot:bot.name,reply,commandId:command.id}));
+  await awaitDelivery(db,request,bot.id,reply,command.id);
   await cleanupConversations(db);
 
   return {ok:true,ran:true,speaker:request.speakerName,name:bot.name,channel:request.channel,reply,commandId:command.id};
diff --git a/scripts/test-core.mjs b/scripts/test-core.mjs
index 0d25931..ca327cf 100644
--- a/scripts/test-core.mjs
+++ b/scripts/test-core.mjs
@@ -1,6 +1,6 @@
 import {spawnSync} from 'node:child_process';
 import {writeFileSync,mkdirSync} from 'node:fs';
-const result=spawnSync(process.execPath,['node_modules/typescript/bin/tsc','core/service.ts','core/seed.ts','core/ale.ts','--outDir','.test-build','--module','commonjs','--target','es2022','--moduleResolution','node','--esModuleInterop','--skipLibCheck','--strict'],{stdio:'inherit'});
+const result=spawnSync(process.execPath,['node_modules/typescript/bin/tsc','core/service.ts','core/seed.ts','core/ale.ts','core/conversation.ts','--types','@cloudflare/workers-types,node','--outDir','.test-build','--module','commonjs','--target','es2022','--moduleResolution','node','--esModuleInterop','--skipLibCheck','--strict'],{stdio:'inherit'});
 if(result.status)process.exit(result.status);
 mkdirSync('.test-build',{recursive:true});writeFileSync('.test-build/package.json','{"type":"commonjs"}');
-process.exit(spawnSync(process.execPath,['--test','tests/core.test.cjs','tests/hardcore.test.cjs','tests/living-world.test.cjs','tests/ale.test.cjs','tests/brains.test.cjs'],{stdio:'inherit'}).status??1);
+process.exit(spawnSync(process.execPath,['--test','tests/core.test.cjs','tests/hardcore.test.cjs','tests/living-world.test.cjs','tests/ale.test.cjs','tests/brains.test.cjs','tests/conversation.test.cjs'],{stdio:'inherit'}).status??1);
diff --git a/tests/conversation.test.cjs b/tests/conversation.test.cjs
new file mode 100644
index 0000000..b5e3bce
--- /dev/null
+++ b/tests/conversation.test.cjs
@@ -0,0 +1,41 @@
+const {test}=require('node:test');
+const assert=require('node:assert/strict');
+const queue=require('../.test-build/conversation-store.js');
+const ale=require('../.test-build/ale-store.js');
+const {runConversationTick}=require('../.test-build/conversation.js');
+
+test('conversation failure, queued delivery, confirmed memory and replay safety',async()=>{
+ const request={id:'request-1',speakerName:'Player',message:'Hi',channel:'whisper',receiver:'Resident',nearbyBots:[]};
+ const bot={id:'bot-1',name:'Resident',status:'online',autonomy:{managed:true},memories:[],personality:{},race:'Orc',role:'Warrior'};
+ const state={revision:0,sequence:0,events:[],bots:[bot],settings:{provider:'ollama',model:'test',brains:{enabled:false,residentMemoryLimit:5,residentMaxTokens:100}}};
+ const store={load:async()=>state,save:async()=>{}};
+ let pending=request,delivery=[],queued=0,failed='',completed=0;
+ queue.pendingDeliveries=async()=>delivery;
+ queue.leaseConversation=async()=>{const r=pending;pending=null;return r;};
+ queue.failConversation=async(_db,_id,error)=>{failed=error;};
+ queue.completeConversation=async()=>{completed++;};
+ queue.cleanupConversations=async()=>{};
+ queue.awaitDelivery=async(_db,r,botId,reply,commandId)=>{delivery=[{request:r,botId,reply,commandId,status:'pending'}];};
+ ale.queueAleCommand=async()=>{queued++;return {id:'command-1'};};
+ const originalFetch=global.fetch;
+ try{
+  await assert.rejects(runConversationTick(store,{},{}),/not configured/);
+  assert.match(failed,/no canned reply/);assert.equal(queued,0);assert.equal(bot.memories.length,0);
+  pending=request;global.fetch=async()=>({ok:false,status:503});
+  await assert.rejects(runConversationTick(store,{}, {LLM_URL:'http://model'}),/503/);
+  assert.equal(queued,0);
+  pending=request;global.fetch=async()=>({ok:true,json:async()=>({message:{content:'{"reply":"Hello, traveler."}'}})});
+  await runConversationTick(store,{}, {LLM_URL:'http://model'});
+  assert.equal(queued,1);assert.equal(bot.memories.length,0);assert.equal(completed,0);
+  await runConversationTick(store,{},{});
+  assert.equal(bot.memories.length,0);
+  delivery[0].status='completed';
+  await runConversationTick(store,{},{});
+  assert.equal(bot.memories.length,1);assert.equal(completed,1);
+  await runConversationTick(store,{},{});
+  assert.equal(bot.memories.length,1);
+  delivery=[{...delivery[0],request:{...request,id:'request-2'},status:'failed',error:'Bot offline'}];
+  await runConversationTick(store,{},{});
+  assert.equal(failed,'Bot offline');assert.equal(bot.memories.length,1);
+ }finally{global.fetch=originalFetch;}
+});

From c5f84a7221e8e485493ede33de25b8e0de5d1473 Mon Sep 17 00:00:00 2001
From: Richard Clark <endami@users.noreply.github.com>
Date: Tue, 22 Sep 2026 14:27:17 -0400
Subject: [PATCH 02/13] Disable Actions dependency caching in all workflows

---
 .github/workflows/core-tests.yml        | 1 -
 .github/workflows/full-verification.yml | 2 --
 .github/workflows/realm-simulation.yml  | 1 -
 3 files changed, 4 deletions(-)

diff --git a/.github/workflows/core-tests.yml b/.github/workflows/core-tests.yml
index 3a6c4c8..745ab8d 100644
--- a/.github/workflows/core-tests.yml
+++ b/.github/workflows/core-tests.yml
@@ -18,6 +18,5 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 22
-          cache: pnpm
       - run: pnpm install --frozen-lockfile
       - run: node scripts/test-core.mjs
diff --git a/.github/workflows/full-verification.yml b/.github/workflows/full-verification.yml
index 68df0e1..15e6b17 100644
--- a/.github/workflows/full-verification.yml
+++ b/.github/workflows/full-verification.yml
@@ -18,7 +18,6 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 22
-          cache: pnpm
       - run: pnpm install --frozen-lockfile
       - name: Core and simulation tests
         run: node scripts/test-core.mjs
@@ -62,7 +61,6 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 22
-          cache: pnpm
       - run: pnpm install --frozen-lockfile
       - name: Install Ollama
         run: curl -fsSL https://ollama.com/install.sh | sh
diff --git a/.github/workflows/realm-simulation.yml b/.github/workflows/realm-simulation.yml
index fa1e6ae..3c68cf9 100644
--- a/.github/workflows/realm-simulation.yml
+++ b/.github/workflows/realm-simulation.yml
@@ -31,7 +31,6 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 22
-          cache: pnpm
 
       - run: pnpm install --frozen-lockfile
 

From bc5039522115406ee17918757eb849e63fd2858c Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 22 Sep 2026 15:06:47 -0400
Subject: [PATCH 03/13] Restore live autonomy with direct runtime and fresh
 snapshot capacity

---
 core/autonomy.ts                | 26 +++++++++++++++++++-------
 package.json                    |  4 ++--
 scripts/ale-db-relay.mjs        | 26 +++++++++++++++++++++-----
 scripts/start-local-runtime.mjs | 28 ++++++++++++++++++++++++++++
 scripts/test-core.mjs           |  4 ++--
 tests/autonomy.test.cjs         | 31 +++++++++++++++++++++++++++++++
 6 files changed, 103 insertions(+), 16 deletions(-)
 create mode 100644 scripts/start-local-runtime.mjs
 create mode 100644 tests/autonomy.test.cjs

diff --git a/core/autonomy.ts b/core/autonomy.ts
index 432a801..96bfa38 100644
--- a/core/autonomy.ts
+++ b/core/autonomy.ts
@@ -103,8 +103,8 @@ export async function runLiveAutonomyTick(
  options:{forceBotId?:string;now?:number}={}
 ){
  const now=options.now??Date.now();
- const s=await store.load();
- const revision=s.revision;
+ let s=await store.load();
+ let revision=s.revision;
  const events=await recentAleEvents(db,400);
 
  const candidates=s.bots
@@ -139,29 +139,41 @@ export async function runLiveAutonomyTick(
   return {ok:true,ran:false,reason:options.forceBotId?'No recent authoritative observation for that managed Playerbot':'No managed Playerbot is due with a recent authoritative observation'};
  }
 
- const bot=pick.bot;
+ let bot=pick.bot;
  const observation=observationFrom(bot,pick.obs,events);
  const brain=providerForBot(bot,s.settings,config);
  let decision:Decision;
+ let usedFallback=false;
  try{
   decision=await brain.provider.decide(bot,observation);
  }catch(error){
   if(brain.route.provider==='deterministic')throw error;
   decision=await new DeterministicProvider().decide(bot,observation);
-  realmEvent(s,'system',`${bot.name} LLM route unavailable; used deterministic fallback for this heartbeat.`,bot.id);
+  usedFallback=true;
  }
+ // Model inference can take seconds while authoritative events update state.
+ // Commit the decision against current state, not the pre-inference revision.
+ const botId=bot.id;
+ s=await store.load();
+ revision=s.revision;
+ const currentBot=s.bots.find(b=>b.id===botId);
+ if(!currentBot||currentBot.status==='dead'||currentBot.status==='retired'||!currentBot.autonomy?.managed){
+  return {ok:true,ran:false,reason:'Resident is no longer eligible for an autonomous intention'};
+ }
+ bot=currentBot;
+ if(usedFallback)realmEvent(s,'system',`${bot.name} LLM route unavailable; used deterministic fallback for this heartbeat.`,bot.id);
  const source=compileLivePlayerbotIntent(bot.name,decision);
  const queued=await queueAleCommand(db,source);
 
  bot.lastDecision=decision;
  bot.decisions++;
  bot.goal=decision.goal;
- bot.level=observation.level;
- bot.zone=observation.zone;
+ const newerObservation=Date.parse(bot.autonomy?.observedAt??'')>Date.parse(pick.obs.at);
+ if(!newerObservation){bot.level=observation.level;bot.zone=observation.zone;}
  bot.autonomy={
   ...(bot.autonomy??{}),
   managed:true,
-  observedAt:pick.obs.at,
+  observedAt:newerObservation?bot.autonomy?.observedAt:pick.obs.at,
   lastIntentAt:new Date(now).toISOString(),
   nextIntentAt:new Date(now+nextIntervalMs(bot)).toISOString(),
   lastAleCommandId:queued.id
diff --git a/package.json b/package.json
index 0cb0a5f..b8b10c4 100644
--- a/package.json
+++ b/package.json
@@ -9,11 +9,11 @@
     "install:ci": "bash scripts/install-pnpm.sh",
     "dev": "node scripts/run-framework.mjs dev",
     "build": "node scripts/run-framework.mjs build",
-    "start": "node --import ./scripts/sites-env.mjs ./node_modules/wrangler/bin/wrangler.js dev --config dist/server/wrangler.json --local --persist-to .wrangler/state --ip 127.0.0.1 --inspector-port 0 --env-file .dev.vars",
+    "start": "node scripts/start-local-runtime.mjs",
     "lint": "eslint . --ignore-pattern dist --ignore-pattern .next",
     "db:generate": "drizzle-kit generate",
     "bench:brains": "node scripts/benchmark-brains.mjs",
-    "start:lan": "node --import ./scripts/sites-env.mjs ./node_modules/wrangler/bin/wrangler.js dev --config dist/server/wrangler.json --local --persist-to .wrangler/state --ip 0.0.0.0 --port 8787 --inspector-port 0 --env-file .dev.vars"
+    "start:lan": "node scripts/start-local-runtime.mjs --lan"
   },
   "dependencies": {
     "@base-ui/react": "^1.7.0",
diff --git a/scripts/ale-db-relay.mjs b/scripts/ale-db-relay.mjs
index f6977b9..a41822b 100644
--- a/scripts/ale-db-relay.mjs
+++ b/scripts/ale-db-relay.mjs
@@ -93,12 +93,20 @@ function rows(sql){
 }
 
 async function deliverEvents(){
+ // Reserve capacity for current snapshots so historical events cannot starve
+ // live decisions. The remaining slots continue draining history in order.
+ const fresh=rows(`SELECT id,HEX(kind),HEX(payload)
+ FROM acore_auth.azerothai_event_outbox
+ WHERE delivered_at IS NULL AND kind='player.snapshot'
+ AND created_at >= NOW() - INTERVAL 90 SECOND
+ ORDER BY id ASC LIMIT ${Math.max(1,Math.floor(EVENT_BATCH/2))}`);
  const batch=rows(`SELECT id,HEX(kind),HEX(payload)
  FROM acore_auth.azerothai_event_outbox
  WHERE delivered_at IS NULL
- ORDER BY CASE WHEN kind IN ('player.whisper','player.chat') THEN 0 ELSE 1 END, id
- LIMIT ${EVENT_BATCH}`);
- for(const [id,kindHex,payloadHex] of batch){
+ ${fresh.length?`AND id NOT IN (${fresh.map(row=>Number(row[0])).join(',')})`:''}
+ ORDER BY CASE WHEN kind IN ('player.whisper','player.chat') AND created_at >= NOW() - INTERVAL 90 SECOND THEN 0 ELSE 1 END, id
+ LIMIT ${Math.max(1,EVENT_BATCH-fresh.length)}`);
+ for(const [id,kindHex,payloadHex] of [...fresh,...batch]){
   const kind=Buffer.from(kindHex||'','hex').toString('utf8');
   const payloadText=Buffer.from(payloadHex||'','hex').toString('utf8');
   let payload;
@@ -116,7 +124,7 @@ async function deliverEvents(){
   mysql(`UPDATE acore_auth.azerothai_event_outbox SET delivered_at=NOW(6) WHERE id=${Number(id)}`);
   if(EVENT_GAP_MS)await sleep(EVENT_GAP_MS);
  }
- return batch.length;
+ return fresh.length+batch.length;
 }
 
 async function deliverResults(){
@@ -136,6 +144,14 @@ async function deliverResults(){
 
 function cleanup(){
  mysql(`
+CREATE TABLE IF NOT EXISTS acore_auth.azerothai_snapshot_archive LIKE acore_auth.azerothai_event_outbox;
+INSERT IGNORE INTO acore_auth.azerothai_snapshot_archive
+ SELECT * FROM acore_auth.azerothai_event_outbox
+ WHERE delivered_at IS NULL AND kind='player.snapshot'
+ AND created_at < NOW() - INTERVAL 90 SECOND;
+UPDATE acore_auth.azerothai_event_outbox e
+ JOIN acore_auth.azerothai_snapshot_archive a ON a.id=e.id
+ SET e.delivered_at=NOW(6) WHERE e.delivered_at IS NULL;
 UPDATE acore_auth.azerothai_event_outbox
  SET delivered_at=NOW(6)
  WHERE delivered_at IS NULL
@@ -151,10 +167,10 @@ console.log(`AzerothAI ALE DB relay started: ${BASE}, poll ${POLL_MS}ms`);
 
 while(!stopping){
  try{
+  if(Date.now()-lastCleanup>60_000){cleanup();lastCleanup=Date.now();}
   await deliverEvents();
   await deliverResults();
   await pullCommand();
-  if(Date.now()-lastCleanup>60_000){cleanup();lastCleanup=Date.now();}
   await sleep(POLL_MS);
  }catch(error){
   console.error(new Date().toISOString(),error instanceof Error?error.message:String(error));
diff --git a/scripts/start-local-runtime.mjs b/scripts/start-local-runtime.mjs
new file mode 100644
index 0000000..fd14756
--- /dev/null
+++ b/scripts/start-local-runtime.mjs
@@ -0,0 +1,28 @@
+// Run the built worker without Wrangler's development proxy or file watcher.
+import './sites-env.mjs';
+import {createRequire} from 'node:module';
+import path from 'node:path';
+import {readdirSync} from 'node:fs';
+import {unstable_getMiniflareWorkerOptions} from 'wrangler';
+
+const require = createRequire(import.meta.url);
+const wranglerRequire = createRequire(require.resolve('wrangler'));
+const {Miniflare} = wranglerRequire('miniflare');
+const config = path.resolve('dist/server/wrangler.json');
+const {workerOptions, externalWorkers, main} = unstable_getMiniflareWorkerOptions(config);
+if (!main) throw new Error('Build the application before starting the local runtime');
+const root = path.dirname(main);
+const modules = readdirSync(root, {recursive: true})
+  .filter(file => /\.(m?js)$/.test(file))
+  .map(file => ({type: 'ESModule', path: path.join(root, file)}));
+modules.sort((a, b) => a.path === main ? -1 : b.path === main ? 1 : 0);
+const runtime = new Miniflare({
+  host: process.env.RUNTIME_HOST || (process.argv.includes('--lan') ? '0.0.0.0' : '127.0.0.1'),
+  port: Number(process.env.RUNTIME_PORT || 8787),
+  d1Persist: path.resolve('.wrangler/state/v3/d1'),
+  workers: [{...workerOptions, modules, modulesRoot: root}, ...externalWorkers],
+});
+console.log(`AzerothAI local runtime ready: ${await runtime.ready}`);
+for (const signal of ['SIGINT', 'SIGTERM']) {
+  process.once(signal, async () => { await runtime.dispose(); process.exit(0); });
+}
diff --git a/scripts/test-core.mjs b/scripts/test-core.mjs
index ca327cf..aa89814 100644
--- a/scripts/test-core.mjs
+++ b/scripts/test-core.mjs
@@ -1,6 +1,6 @@
 import {spawnSync} from 'node:child_process';
 import {writeFileSync,mkdirSync} from 'node:fs';
-const result=spawnSync(process.execPath,['node_modules/typescript/bin/tsc','core/service.ts','core/seed.ts','core/ale.ts','core/conversation.ts','--types','@cloudflare/workers-types,node','--outDir','.test-build','--module','commonjs','--target','es2022','--moduleResolution','node','--esModuleInterop','--skipLibCheck','--strict'],{stdio:'inherit'});
+const result=spawnSync(process.execPath,['node_modules/typescript/bin/tsc','core/service.ts','core/seed.ts','core/ale.ts','core/conversation.ts','core/autonomy.ts','--types','@cloudflare/workers-types,node','--outDir','.test-build','--module','commonjs','--target','es2022','--moduleResolution','node','--esModuleInterop','--skipLibCheck','--strict'],{stdio:'inherit'});
 if(result.status)process.exit(result.status);
 mkdirSync('.test-build',{recursive:true});writeFileSync('.test-build/package.json','{"type":"commonjs"}');
-process.exit(spawnSync(process.execPath,['--test','tests/core.test.cjs','tests/hardcore.test.cjs','tests/living-world.test.cjs','tests/ale.test.cjs','tests/brains.test.cjs','tests/conversation.test.cjs'],{stdio:'inherit'}).status??1);
+process.exit(spawnSync(process.execPath,['--test','tests/core.test.cjs','tests/hardcore.test.cjs','tests/living-world.test.cjs','tests/ale.test.cjs','tests/brains.test.cjs','tests/conversation.test.cjs','tests/autonomy.test.cjs'],{stdio:'inherit'}).status??1);
diff --git a/tests/autonomy.test.cjs b/tests/autonomy.test.cjs
new file mode 100644
index 0000000..7f8c2f9
--- /dev/null
+++ b/tests/autonomy.test.cjs
@@ -0,0 +1,31 @@
+const {test}=require('node:test');
+const assert=require('node:assert/strict');
+const ale=require('../.test-build/ale-store.js');
+const llm=require('../.test-build/llm/index.js');
+const {runLiveAutonomyTick}=require('../.test-build/autonomy.js');
+
+test('inference preserves intervening observations and cancels after retirement',async()=>{
+ const now=Date.now();
+ const bot={id:'hero',name:'Zaku',status:'online',tier:'hero',decisions:0,
+  personality:{activities:['explore']},autonomy:{managed:true},level:5,zone:'Old zone'};
+ let state={revision:1,bots:[bot],events:[],sequence:0,settings:{}};
+ const store={load:async()=>structuredClone(state),save:async(s,revision)=>{
+  assert.equal(revision,state.revision);state=s;
+ }};
+ ale.recentAleEvents=async()=>[{at:new Date(now).toISOString(),kind:'player.snapshot',payload:{name:'Zaku',isBot:true,level:5,zoneName:'Old zone'}}];
+ let queued=0,retire=false;
+ ale.queueAleCommand=async()=>{queued++;return {id:'intent'};};
+ llm.providerForBot=()=>({route:{provider:'ollama',model:'test'},provider:{decide:async()=>{
+  state.revision++;
+  state.bots[0].level=6;state.bots[0].zone='New zone';
+  state.bots[0].autonomy.observedAt=new Date(now+1000).toISOString();
+  if(retire)state.bots[0].status='retired';
+  return {action:'explore',goal:'Explore nearby',reason:'Curious'};
+ }}});
+ assert.equal((await runLiveAutonomyTick(store,{}, {},{now})).ran,true);
+ assert.equal(state.bots[0].level,6);assert.equal(state.bots[0].zone,'New zone');
+ assert.equal(queued,1);
+ retire=true;
+ assert.equal((await runLiveAutonomyTick(store,{}, {},{now,forceBotId:'hero'})).ran,false);
+ assert.equal(queued,1);
+});

From 77f6b56c2f5840ee57635c52fdd023e95d497dac Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 22 Sep 2026 15:55:41 -0400
Subject: [PATCH 04/13] Enforce hardcore retirement with level-one
 faction-balanced replacements

---
 ale/azerothai_bridge.lua             |  15 ++-
 ale/azerothai_lifecycle.lua          | 190 +++++++++++++++++++++++++++
 app/api/bridge/ale/event/route.ts    |   1 +
 app/page.tsx                         |   2 +-
 core/service.ts                      |   2 +-
 deploy/playable/install-lifecycle.py | 133 +++++++++++++++++++
 docs/hardcore-replacement.md         |  56 ++++++++
 scripts/ale-db-relay.mjs             |   2 +-
 tests/hardcore.test.cjs              |  13 ++
 tests/lifecycle-lua.test.py          | 117 +++++++++++++++++
 10 files changed, 526 insertions(+), 5 deletions(-)
 create mode 100644 ale/azerothai_lifecycle.lua
 create mode 100644 deploy/playable/install-lifecycle.py
 create mode 100644 docs/hardcore-replacement.md
 create mode 100644 tests/lifecycle-lua.test.py

diff --git a/ale/azerothai_bridge.lua b/ale/azerothai_bridge.lua
index 0fd512a..9056345 100644
--- a/ale/azerothai_bridge.lua
+++ b/ale/azerothai_bridge.lua
@@ -85,6 +85,11 @@ local function emit(kind, payload)
  AuthDBExecute(sql)
 end
 
+local function area_name(id)
+ local ok,name=pcall(GetAreaName,id)
+ return ok and name or tostring(id)
+end
+
 local function player_payload(player)
  if not player then return {} end
  local isBot = is_playerbot(player)
@@ -96,7 +101,7 @@ local function player_payload(player)
   mapId=player:GetMapId(),
   zoneId=player:GetZoneId(),
   areaId=player:GetAreaId(),
-  zoneName=GetAreaName(player:GetZoneId()) or tostring(player:GetZoneId()),
+  zoneName=area_name(player:GetZoneId()),
   race=player:GetRace(),
   class=player:GetClass(),
   raceName=player:GetRaceAsString() or tostring(player:GetRace()),
@@ -136,6 +141,12 @@ function AzerothAIEmitPlayerSnapshot(name)
  return 1
 end
 
+function AzerothAIEmitPermanentDeath(player)
+ local payload=player_payload(player)
+ payload.deathId="hardcore-"..tostring(player:GetGUIDLow())
+ emit("player.permanent-death",payload)
+end
+
 local function mark_consumed(id)
  AuthDBExecute("UPDATE azerothai_command_inbox SET consumed_at=NOW() WHERE id=" .. db_text(to_hex(id)))
 end
@@ -254,7 +265,7 @@ RegisterPlayerEvent(27, function(event, player, newZone, newArea)
  local payload=player_payload(player)
  payload.zone=newZone
  payload.area=newArea
- payload.zoneName=GetAreaName(newZone) or tostring(newZone)
+ payload.zoneName=area_name(newZone)
  emit("player.zone",payload)
 end)
 
diff --git a/ale/azerothai_lifecycle.lua b/ale/azerothai_lifecycle.lua
new file mode 100644
index 0000000..6952d26
--- /dev/null
+++ b/ale/azerothai_lifecycle.lua
@@ -0,0 +1,190 @@
+-- Persistent hardcore retirement. The native random-bot manager fills vacancies
+-- from its factory-created, unused level-1 reserve; identities are never reset.
+-- Install only after deploy/playable/install-lifecycle.py has seeded the registry.
+local residents = {}
+local ready = false
+local vetoAt = {}
+local unmanaged = {}
+local TARGET_PER_FACTION = 25
+local gates = {}
+local gateAt = {}
+local arrivals = {}
+local alliance = {[1]=true,[3]=true,[4]=true,[7]=true,[11]=true}
+local horde = {[2]=true,[5]=true,[6]=true,[8]=true,[10]=true}
+local function faction(row)
+ if alliance[row.race] then return 1 end
+ if horde[row.race] then return 2 end
+ return nil
+end
+
+local function sqltext(value)
+ return "CONVERT(UNHEX('"..(string.gsub(value,".",function(c) return string.format("%02X",string.byte(c)) end)).."') USING utf8mb4)"
+end
+
+local function enroll(player)
+ local guid=player:GetGUIDLow()
+ if unmanaged[guid] then return nil end
+ local account=player:GetAccountId()
+ local name=player:GetName()
+ if string.lower(name)=="zaku" then return nil end
+ -- The native factory can create additional accounts during startup. Accept
+ -- only its accounts and only genuinely unused characters as new residents.
+ local owned=AuthDBQuery("SELECT id FROM account WHERE id="..account.." AND username REGEXP '^RNDBOT[0-9]+$'")
+ if not owned then unmanaged[guid]=true;return nil end
+ local character=CharDBQuery("SELECT totaltime FROM characters WHERE guid="..guid.." AND account="..account)
+ if not character then return nil end
+ local state=(player:GetLevel()==1 and character:GetUInt32(0)<=60) and "reserve" or "blocked"
+ local row={name=name,account=account,protected=false,state=state,race=player:GetRace()}
+ residents[guid]=row
+ AuthDBExecute("INSERT IGNORE INTO azerothai_lifecycle(guid,name,account_id,protected,state,race) VALUES ("..
+  guid..","..sqltext(name)..","..account..",0,"..sqltext(state)..","..row.race..")")
+ return row
+end
+
+local function reload()
+ local q=AuthDBQuery("SELECT guid,name,account_id,protected,state,race FROM azerothai_lifecycle")
+ if not q then error("AzerothAI lifecycle registry is unavailable or empty") end
+ local nextResidents={}
+ repeat
+  nextResidents[q:GetUInt32(0)]={name=q:GetString(1),account=q:GetUInt32(2),
+   protected=q:GetUInt32(3)==1,state=q:GetString(4),race=q:GetUInt32(5)}
+ until not q:NextRow()
+ residents=nextResidents
+ ready=true
+end
+
+local function identity(player)
+ if not ready or not player then return nil end
+ local guid=player:GetGUIDLow()
+ local row=residents[guid] or enroll(player)
+ if not row or row.account~=player:GetAccountId() or row.name~=player:GetName() then return nil end
+ if row.protected or string.lower(row.name)=="zaku" then return nil end
+ return row,guid
+end
+
+local function recordDeath(player)
+ local row,guid=identity(player)
+ if not row or row.state=="dead" or row.state=="blocked" then return end
+ row.state="dead"
+ AuthDBExecute("UPDATE azerothai_lifecycle SET state='dead',died_at=COALESCE(died_at,NOW()) WHERE guid="..
+  guid.." AND protected=0 AND LOWER(name)<>'zaku'")
+ if AzerothAIEmitPermanentDeath then AzerothAIEmitPermanentDeath(player) end
+end
+
+local function enforce()
+ if not ready then reload() end
+ local mgr=GetRandomPlayerbotMgr()
+ -- Disallow every retired identity before the native manager fills vacancies.
+ for guid,row in pairs(residents) do
+  if (row.state=="dead" or row.state=="blocked") and not row.protected and string.lower(row.name)~="zaku" then
+   local player=GetPlayerByName(row.name)
+   local removed=false
+   if player and player:GetGUIDLow()==guid and player:GetAccountId()==row.account then
+    mgr:Remove(player)
+    removed=true
+   end
+   -- Remove clears the manager's event cache, so set the login veto afterward.
+   if removed or not vetoAt[guid] or os.time()-vetoAt[guid]>300 then
+    mgr:SetValue(guid,"add",0)
+    mgr:SetValue(guid,"logout",1,"AzerothAI permanent retirement")
+    vetoAt[guid]=os.time()
+   end
+  end
+ end
+ local players=GetPlayersInWorld() or {}
+ local counts={0,0}
+ local online={}
+ local returning={}
+ for _,player in pairs(players) do
+  local guid=player:GetGUIDLow()
+  local row=residents[guid]
+  if row and row.state=="active" and row.account==player:GetAccountId() and row.name==player:GetName() and not player:IsDead() then
+   returning[#returning+1]={player=player,row=row,guid=guid}
+  end
+ end
+ table.sort(returning,function(a,b)
+  local ap=a.row.protected or string.lower(a.row.name)=="zaku"
+  local bp=b.row.protected or string.lower(b.row.name)=="zaku"
+  if ap~=bp then return ap end
+  return a.guid<b.guid
+ end)
+ for _,item in ipairs(returning) do
+  local team=faction(item.row)
+  if team then
+   if counts[team]<TARGET_PER_FACTION or item.row.protected or string.lower(item.row.name)=="zaku" then
+    counts[team]=counts[team]+1
+    online[item.guid]=true
+   else
+    -- Returning residents keep their identity and progress while held offline.
+    mgr:Remove(item.player)
+    mgr:SetValue(item.guid,"logout",1,"AzerothAI faction capacity")
+    gates[item.guid]=false
+    gateAt[item.guid]=os.time()
+   end
+  end
+ end
+ players=GetPlayersInWorld() or {}
+ for _,player in pairs(players) do
+  local row,guid=identity(player)
+  if row and row.state~="dead" and row.state~="blocked" then
+   if player:IsDead() then
+    recordDeath(player)
+   elseif row.state=="reserve" then
+    if (arrivals[guid] or player:GetLevel())~=1 then
+     row.state="blocked"
+     AuthDBExecute("UPDATE azerothai_lifecycle SET state='blocked' WHERE guid="..guid.." AND state='reserve'")
+     PrintError("[AzerothAI] Replacement did not start at level 1: "..row.name)
+    elseif faction(row) and counts[faction(row)]<TARGET_PER_FACTION then
+     counts[faction(row)]=counts[faction(row)]+1
+     row.state="active"
+     online[guid]=true
+     AuthDBExecute("UPDATE azerothai_lifecycle SET state='active',entry_level=1,activated_at=COALESCE(activated_at,NOW()) WHERE guid="..guid.." AND state='reserve'")
+     if AzerothAIEmitPlayerSnapshot then AzerothAIEmitPlayerSnapshot(row.name) end
+     PrintInfo("[AzerothAI] New level-1 resident entered the world: "..row.name)
+    else
+     -- A login already in flight must not push its faction over the target.
+     mgr:Remove(player)
+     mgr:SetValue(guid,"logout",1,"AzerothAI faction capacity")
+     gates[guid]=false
+     gateAt[guid]=os.time()
+    end
+   end
+  end
+ end
+ -- Open only enough fresh identities to fill each faction's actual deficit.
+ -- Persisted login vetoes keep the native random selector inside these slots.
+ local slots={math.max(0,TARGET_PER_FACTION-counts[1]),math.max(0,TARGET_PER_FACTION-counts[2])}
+ local candidates={}
+ for guid,row in pairs(residents) do if (row.state=="reserve" or row.state=="active") and not online[guid] and not row.protected and string.lower(row.name)~="zaku" then candidates[#candidates+1]=guid end end
+ table.sort(candidates,function(a,b)
+  if residents[a].state~=residents[b].state then return residents[a].state=="active" end
+  return a<b
+ end)
+ for _,guid in ipairs(candidates) do
+  local team=faction(residents[guid])
+  local allowed=team~=nil and slots[team]>0
+  if allowed then slots[team]=slots[team]-1 end
+  if gates[guid]~=allowed or not gateAt[guid] or os.time()-gateAt[guid]>300 then
+   mgr:SetValue(guid,"logout",allowed and 0 or 1,"AzerothAI faction capacity")
+   gates[guid]=allowed
+   gateAt[guid]=os.time()
+  end
+  if not allowed and mgr:GetValue(guid,"add")~=0 then mgr:SetValue(guid,"add",0) end
+ end
+end
+
+-- Record death synchronously in memory; logout happens outside the death hook.
+RegisterPlayerEvent(8,function(event,killer,killed) recordDeath(killed) end)
+RegisterPlayerEvent(6,function(event,killer,killed) recordDeath(killed) end)
+RegisterPlayerEvent(3,function(event,player)
+ local row,guid=identity(player)
+ if row and row.state=="reserve" then arrivals[guid]=player:GetLevel() end
+end)
+CreateLuaEvent(function()
+ local ok,err=pcall(enforce)
+ if not ok then PrintError("[AzerothAI] Lifecycle enforcement failed: "..tostring(err)) end
+end,1000,0)
+
+reload()
+enforce()
+PrintInfo("[AzerothAI] Persistent hardcore retirement and reserve replacement enabled")
diff --git a/app/api/bridge/ale/event/route.ts b/app/api/bridge/ale/event/route.ts
index 758a74b..6437f5d 100644
--- a/app/api/bridge/ale/event/route.ts
+++ b/app/api/bridge/ale/event/route.ts
@@ -25,6 +25,7 @@ const STATEFUL_EVENTS=new Set([
  'player.achievement',
  'player.close-call',
  'player.killed-by-creature',
+ 'player.permanent-death',
  'player.repop',
  'player.resurrect'
 ]);
diff --git a/app/page.tsx b/app/page.tsx
index 5a4039c..b73b0d7 100644
--- a/app/page.tsx
+++ b/app/page.tsx
@@ -41,7 +41,7 @@ export default function Home(){
  <div className="page-heading"><div><div className="eyebrow">{page==='GM Console'?'THE WORLD IS YOUR SANDBOX':'AZEROTHAI CONTROL PLANE'}</div><h1>{page==='Dashboard'?'Your realm, alive.':page}</h1><p className="subtitle">{({'Dashboard':'The people, personalities, and stories that make your world.','World Monitor':'Watch Azeroth breathe: population, activity, systems, and the lives unfolding right now.','Realm Director':'Shape the adventure around you. Let your characters bring it to life.','World & Housing':'Homes, routines, simulation bands, and believable population flow.','Bots':'Give every character a purpose, then let their story unfold.','Bot Recipes':'Same model. Different personalities. A world of possibilities.','Memory & Bonds':'A shared history makes the next encounter matter.','Event Stream':'Follow the decisions and changes happening across your realm.','GM Console':'Pull up a chair. Put on the blue robe. Run your world.','Server & Models':'Connect the game engine and the minds behind your characters.'} as any)[page]}</p></div><div className="actions">{page==='Bot Recipes'?<Button onClick={()=>{setRecipe(null);setRecipeOpen(true)}}><Plus size={16}/>Create recipe</Button>:<><Button variant="outline" disabled={busy} onClick={()=>void refresh()}><RefreshCw size={15}/>Refresh</Button><Button onClick={()=>setCreateOpen(true)}><Plus size={16}/>Create bot</Button></>}</div></div>
  {error&&<div className="notice" role="alert">{error} <Button variant="outline" onClick={()=>void refresh()}>Retry</Button></div>}
  {!state?<div className="stats">{[1,2,3,4].map(n=><Skeleton key={n} className="h-32"/>)}</div>:<>
- {page==='Dashboard'&&<><div className="stats">{[[Users,'Active bots',state.bots.filter(b=>b.status==='online').length,'Online in the simulation'],[BookOpen,'Bot recipes',state.recipes.length,'Distinct ways to experience the world'],[Brain,'Memories',state.bots.reduce((n,b)=>n+b.memories.length,0),'Stories carried into future decisions'],[Network,'Relationships',state.bots.reduce((n,b)=>n+b.relationships.length,0),'Directed bonds between characters']].map(([Icon,label,value,note]:any)=><div className="panel stat" key={label}><div className="stat-label">{label}<Icon/></div><div className="stat-value">{value}</div><small>{label==='Active bots'&&state.settings.connector!=='simulation'?'Acknowledged by the game bridge':note}</small></div>)}</div><section className="panel director-strip"><div className="director-content"><Compass className="director-icon"/><div><div className="eyebrow">YOUR NEXT ADVENTURE</div><h2>{state.director.experience}</h2><p>{state.director.zone} · {state.director.brief}</p></div></div><Button variant="outline" onClick={()=>nav('Realm Director')}>Shape the experience <ArrowRight size={15}/></Button></section><div className="dashboard-grid"><Panel title="Your characters" icon={Users} action={<Button variant="ghost" size="sm" onClick={()=>nav('Bots')}>Manage bots <ArrowRight size={14}/></Button>}>{botTable(state.bots.slice(0,5))}</Panel><Panel title="Realm pulse" icon={Radio}><div className="panel-body">{Array.from(new Set(state.bots.filter(b=>b.status==='online').map(b=>b.zone))).map(zone=>{const n=state.bots.filter(b=>b.status==='online'&&b.zone===zone).length;return <div className="zone-row" key={zone}><span className="zone-label">{zone}</span><span className="bar"><i style={{width:`${n/Math.max(1,state.bots.filter(b=>b.status==='online').length)*100}%`}}/></span><span>{n}</span></div>})}<p className="fineprint">Bot locations from the selected connector. Simulation locations are illustrative.</p><div className="engine-box" style={{marginTop:25,marginBottom:0}}><Brain size={23}/><div><h3>{state.settings.provider==='deterministic'?'Personality simulator':state.settings.model}</h3><p>{state.settings.provider==='deterministic'?'No model required. Try a decision from any online bot.':'Local model selected. Each decision includes identity and memories.'}</p></div></div></div></Panel><Panel title="Recent activity" icon={Activity} action={<Button variant="ghost" size="sm" onClick={()=>nav('Event Stream')}>View stream <ArrowRight size={14}/></Button>}>{<Events events={state.events.slice(-5)}/>}</Panel><Panel title="The Game Master’s chair" icon={Shield}><div className="panel-body"><p className="list-muted">Set the scene. Announce a gathering. Move a character to the next chapter of their story.</p><div className="gm-preview"><span>&lt;GM&gt; AzerothAI</span><p>Welcome to your world.</p><code>.announce An adventure awaits...</code></div><Button variant="outline" onClick={()=>nav('GM Console')}>Open GM console <Terminal size={15}/></Button></div></Panel></div></>}
+ {page==='Dashboard'&&<><div className="stats">{[[Users,'Active bots',state.bots.filter(b=>b.status==='online'&&(state.settings.connector==='simulation'||b.autonomy?.managed)).length,'Online in the simulation'],[BookOpen,'Bot recipes',state.recipes.length,'Distinct ways to experience the world'],[Brain,'Memories',state.bots.reduce((n,b)=>n+b.memories.length,0),'Stories carried into future decisions'],[Network,'Relationships',state.bots.reduce((n,b)=>n+b.relationships.length,0),'Directed bonds between characters']].map(([Icon,label,value,note]:any)=><div className="panel stat" key={label}><div className="stat-label">{label}<Icon/></div><div className="stat-value">{value}</div><small>{label==='Active bots'&&state.settings.connector!=='simulation'?'Acknowledged by the game bridge':note}</small></div>)}</div><section className="panel director-strip"><div className="director-content"><Compass className="director-icon"/><div><div className="eyebrow">YOUR NEXT ADVENTURE</div><h2>{state.director.experience}</h2><p>{state.director.zone} · {state.director.brief}</p></div></div><Button variant="outline" onClick={()=>nav('Realm Director')}>Shape the experience <ArrowRight size={15}/></Button></section><div className="dashboard-grid"><Panel title="Your characters" icon={Users} action={<Button variant="ghost" size="sm" onClick={()=>nav('Bots')}>Manage bots <ArrowRight size={14}/></Button>}>{botTable(state.bots.slice(0,5))}</Panel><Panel title="Realm pulse" icon={Radio}><div className="panel-body">{Array.from(new Set(state.bots.filter(b=>b.status==='online').map(b=>b.zone))).map(zone=>{const n=state.bots.filter(b=>b.status==='online'&&b.zone===zone).length;return <div className="zone-row" key={zone}><span className="zone-label">{zone}</span><span className="bar"><i style={{width:`${n/Math.max(1,state.bots.filter(b=>b.status==='online').length)*100}%`}}/></span><span>{n}</span></div>})}<p className="fineprint">Bot locations from the selected connector. Simulation locations are illustrative.</p><div className="engine-box" style={{marginTop:25,marginBottom:0}}><Brain size={23}/><div><h3>{state.settings.provider==='deterministic'?'Personality simulator':state.settings.model}</h3><p>{state.settings.provider==='deterministic'?'No model required. Try a decision from any online bot.':'Local model selected. Each decision includes identity and memories.'}</p></div></div></div></Panel><Panel title="Recent activity" icon={Activity} action={<Button variant="ghost" size="sm" onClick={()=>nav('Event Stream')}>View stream <ArrowRight size={14}/></Button>}>{<Events events={state.events.slice(-5)}/>}</Panel><Panel title="The Game Master’s chair" icon={Shield}><div className="panel-body"><p className="list-muted">Set the scene. Announce a gathering. Move a character to the next chapter of their story.</p><div className="gm-preview"><span>&lt;GM&gt; AzerothAI</span><p>Welcome to your world.</p><code>.announce An adventure awaits...</code></div><Button variant="outline" onClick={()=>nav('GM Console')}>Open GM console <Terminal size={15}/></Button></div></Panel></div></>}
  {page==='World Monitor'&&<WorldMonitor state={state} monitor={monitor} capabilities={capabilities} openBot={setBotId}/>}
  {page==='Bots'&&<><div className="toolbar"><Input aria-label="Search bots" placeholder="Search name, class, or location…" value={query} onChange={e=>setQuery(e.target.value)}/><Choice label="Bot status" value={filter} onChange={setFilter} items={options(['all','online','paused','offline','retired'])}/><small>{visible.length} characters</small></div><Panel title="Bot lifecycle" icon={Users}>{visible.length?botTable(visible):<div className="empty-note">No matching bots. Create a character or adjust your filters.</div>}</Panel></>}
  {page==='Bot Recipes'&&<><div className="notice">Recipes are versioned. Saving a recipe preserves existing bots’ personalities until you explicitly apply the new version.</div><div className="recipe-grid">{state.recipes.map((r,i)=><button key={r.id} className="panel recipe-card" onClick={()=>{setRecipe(r);setRecipeOpen(true)}}><div style={{display:'flex',justifyContent:'space-between'}}><span className="recipe-symbol">{i%2?<Compass size={23}/>:<BookOpen size={23}/>}</span><small>VERSION {r.version}</small></div><h3>{r.name}</h3><p>{r.description}</p><div className="tags">{r.tags.map(t=><span className="tag" key={t}>{t}</span>)}</div><div style={{display:'flex',justifyContent:'space-between',marginTop:21}}><small>{state.bots.filter(b=>b.recipeId===r.id).length} bot identities</small><small style={{color:'#9abef7'}}>Edit recipe →</small></div></button>)}</div></>}
diff --git a/core/service.ts b/core/service.ts
index 91d0d51..9d0e392 100644
--- a/core/service.ts
+++ b/core/service.ts
@@ -179,7 +179,7 @@ export async function applyAuthoritativeAleEvent(store:StateStore,kind:string,pa
    b.memories=b.memories.slice(-100);
   }
   event(s,'memory',`${b.name} survived a close call in ${b.zone}; the experience was committed to memory.`,b.id);
- }else if(kind==='player.killed-by-creature'){
+ }else if(kind==='player.killed-by-creature'||kind==='player.permanent-death'){
   if(b.plotArmorHpFloor>=1){
    event(s,'error',`Plot armor breach: authoritative ALE reported ${b.name} dead. Worldserver damage enforcement must prevent this transition.`,b.id);
   }else if(s.settings.hardcore.enabled){
diff --git a/deploy/playable/install-lifecycle.py b/deploy/playable/install-lifecycle.py
new file mode 100644
index 0000000..dedf758
--- /dev/null
+++ b/deploy/playable/install-lifecycle.py
@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Back up the realm, seed its lifecycle registry, and install the ALE guard.
+
+Run as the Docker-authorized realm owner, with --apply after reviewing the default read-only plan.
+The world server must be stopped for --apply. This script never deletes characters.
+"""
+import argparse
+import datetime
+import gzip
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import subprocess
+import urllib.request
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument('--lab', type=Path, required=True)
+parser.add_argument('--apply', action='store_true')
+args = parser.parse_args()
+repo = Path(__file__).resolve().parents[2]
+lab = args.lab.resolve()
+config = {}
+for line in (lab / 'runtime.env').read_text().splitlines():
+    if '=' in line and not line.startswith('#'):
+        key, value = line.split('=', 1)
+        config[key] = value.strip().strip('"').strip("'")
+env = os.environ.copy()
+env['MYSQL_PWD'] = config['DOCKER_DB_ROOT_PASSWORD']
+
+def mysql(sql):
+    return subprocess.check_output(['docker', 'exec', '-e', 'MYSQL_PWD',
+        'ac-database', 'mysql', '-uroot', '-N', '-B', '-e', sql], env=env, text=True)
+
+state = json.load(urllib.request.urlopen('http://127.0.0.1:8787/api/state', timeout=10))
+assert state['settings']['hardcore']['enabled'], 'Enable hardcore before installing the guard'
+raw = mysql("SELECT c.guid,c.name,c.account,c.level,c.totaltime,c.class FROM acore_characters.characters c "
+    "JOIN acore_auth.account a ON a.id=c.account WHERE a.username REGEXP '^RNDBOT[0-9]+$'")
+characters = [line.split('\t') for line in raw.splitlines() if line]
+managed = {b.get('autonomy', {}).get('characterGuid'): b for b in state['bots']
+    if b.get('autonomy', {}).get('managed')}
+rows = []
+counts = {}
+for guid, name, account, level, played, cls in characters:
+    guid, account = int(guid), int(account)
+    bot = managed.get(guid)
+    if bot:
+        assert bot['name'] == name and bot['autonomy']['accountId'] == account, 'Identity mismatch'
+    protected = name.lower() == 'zaku' or bool(bot and bot.get('plotArmorHpFloor', 0) > 0)
+    if protected:
+        status = 'active'
+    elif bot and bot['status'] == 'dead':
+        assert bot.get('death', {}).get('verified'), 'Unverified death cannot retire a character'
+        status = 'dead'
+    elif bot and bot['status'] != 'retired':
+        status = 'active'
+    elif int(level) == 1 and int(played) == 0 and int(cls) != 6:
+        status = 'reserve'
+    else:
+        status = 'blocked'
+    counts[status] = counts.get(status, 0) + 1
+    rows.append((guid, name, account, int(protected), status))
+assert any(name.lower() == 'zaku' and protected for _, name, _, protected, _ in rows)
+assert counts.get('reserve', 0) >= counts.get('dead', 0), 'Insufficient unused level-1 reserve'
+print('Lifecycle plan:', json.dumps(counts), flush=True)
+if not args.apply:
+    raise SystemExit(0)
+running = json.loads(subprocess.check_output(['docker', 'inspect', 'ac-worldserver']))[0]['State']['Running']
+assert not running, 'Stop ac-worldserver before applying this migration'
+os.umask(0o077)
+backup = lab / ('lifecycle-backup-' + datetime.datetime.now(datetime.timezone.utc).strftime('%Y%m%dT%H%M%SZ'))
+backup.mkdir()
+(backup / 'realm-state.json').write_text(json.dumps(state))
+(backup / 'registry-plan.json').write_text(json.dumps(rows))
+dump = subprocess.Popen(['docker', 'exec', '-e', 'MYSQL_PWD', 'ac-database',
+    'mysqldump', '-uroot', '--single-transaction', '--no-tablespaces', '--set-gtid-purged=OFF',
+    '--databases', 'acore_auth', 'acore_characters', 'acore_playerbots'], env=env, stdout=subprocess.PIPE)
+with gzip.open(backup / 'realm.sql.gz', 'wb') as stream:
+    shutil.copyfileobj(dump.stdout, stream)
+assert dump.wait() == 0, 'Database backup failed; no migration applied'
+core = lab / 'azerothcore'
+override = core / 'docker-compose.override.yml'
+shutil.copy2(override, backup / override.name)
+shutil.copytree(core / 'azerothai-lua', backup / 'azerothai-lua')
+mysql('''CREATE TABLE IF NOT EXISTS acore_auth.azerothai_lifecycle (
+ guid INT UNSIGNED PRIMARY KEY, name VARCHAR(64) NOT NULL,
+ account_id INT UNSIGNED NOT NULL, protected TINYINT NOT NULL DEFAULT 0,
+ state VARCHAR(16) NOT NULL, died_at TIMESTAMP NULL, activated_at TIMESTAMP NULL,
+ race TINYINT UNSIGNED NOT NULL DEFAULT 0, entry_level TINYINT UNSIGNED NULL
+) ENGINE=InnoDB''')
+for column, definition in [('race', 'TINYINT UNSIGNED NOT NULL DEFAULT 0'), ('entry_level', 'TINYINT UNSIGNED NULL')]:
+    if not mysql(f"SHOW COLUMNS FROM acore_auth.azerothai_lifecycle LIKE '{column}'").strip():
+        mysql(f'ALTER TABLE acore_auth.azerothai_lifecycle ADD COLUMN {column} {definition}')
+def text(value):
+    return "CONVERT(UNHEX('" + value.encode().hex() + "') USING utf8mb4)"
+# Never overwrite existing ledger history on a repeated installation.
+values = [f"({guid},{text(name)},{account},{protected},{text(status)},"
+    + ("NOW())" if status == 'dead' else "NULL)")
+    for guid, name, account, protected, status in rows]
+mysql("INSERT IGNORE INTO acore_auth.azerothai_lifecycle "
+      "(guid,name,account_id,protected,state,died_at) VALUES " + ','.join(values))
+mysql("UPDATE acore_auth.azerothai_lifecycle l JOIN acore_characters.characters c "
+      "ON c.guid=l.guid AND c.account=l.account_id AND c.name=l.name SET l.race=c.race")
+# The native factory separates manual AddClass accounts from autonomous accounts.
+# Make the verified unused reserve selectable without increasing the online cap.
+mysql("UPDATE acore_playerbots.playerbots_account_type t "
+      "JOIN acore_auth.azerothai_lifecycle l ON l.account_id=t.account_id "
+      "SET t.account_type=1,t.assignment_date=NOW() WHERE l.state='reserve'")
+source = (repo / 'ale/azerothai_bridge.lua').read_text()
+current = (core / 'azerothai-lua/azerothai_bridge.lua').read_text()
+for key in ['POLL_MS', 'PROTECTED', 'KNOWN_BOT_ACCOUNTS']:
+    pattern = r'^local ' + key + r' = .*$'
+    line = re.search(pattern, current, re.M)
+    assert line, key
+    source, n = re.subn(pattern, lambda match: line.group(0), source, flags=re.M)
+    assert n == 1, key
+(core / 'azerothai-lua/azerothai_bridge.lua').write_text(source)
+shutil.copy2(repo / 'ale/azerothai_lifecycle.lua', core / 'azerothai-lua/azerothai_lifecycle.lua')
+settings = {'AC_AI_PLAYERBOT_DISABLE_RANDOM_LEVELS': '1',
+    'AC_AI_PLAYERBOT_RANDOMBOT_STARTING_LEVEL': '1',
+    'AC_AI_PLAYERBOT_DISABLE_DEATH_KNIGHT_LOGIN': '1'}
+content = override.read_text()
+for key, value in settings.items():
+    pattern = r'(?m)^(\s*)' + key + r':.*$'
+    if re.search(pattern, content):
+        content = re.sub(pattern, lambda m: m.group(1) + key + ': "' + value + '"', content)
+    else:
+        assert '    environment:\n' in content, 'Unexpected compose environment layout'
+        content = content.replace('    environment:\n', '    environment:\n      ' + key + ': "' + value + '"\n', 1)
+override.write_text(content)
+print('Migration installed. Backup:', backup, flush=True)
+print('Recreate ac-worldserver to activate; verify the lifecycle startup line and population counts.', flush=True)
diff --git a/docs/hardcore-replacement.md b/docs/hardcore-replacement.md
new file mode 100644
index 0000000..e866b1a
--- /dev/null
+++ b/docs/hardcore-replacement.md
@@ -0,0 +1,56 @@
+# Hardcore population replacement
+
+The game-side ALE lifecycle guard closes an identity permanently after death.
+It preserves character data and the AzerothAI memorial, removes the character
+from the random-bot manager, and refreshes a persistent login veto. Zaku and
+protected identities are excluded. GUID, account and name must all match the
+installation registry; human accounts are never included.
+
+The installer promotes unused manual-summoning reserve accounts into the native
+autonomous pool. The native random-bot manager maintains its configured population target using
+unused factory-created characters. Replacements start at level 1, with their
+own names and AzerothAI recipes/memories assigned when observed. This does not
+reset or resurrect a dead character. Duplicate death events are harmless.
+
+The reserve is finite: this deployment began with 450 unused level-1 characters.
+This release does not create additional accounts or extend the factory reserve
+when it is exhausted. The population will fall below target if no eligible
+characters remain. Check `azerothai_lifecycle` state counts before extending it.
+Death Knights are excluded from new random logins because they do not start at
+level 1. Normal gameplay can still level a replacement after its initial entry.
+
+The guard allocates new arrivals against actual living faction counts, targeting
+25 Alliance and 25 Horde, including protected residents. It holds excess-faction
+reserves and excess returning residents offline without retiring them. Returning
+residents retain their progress and get priority over unused reserves. New activations record `entry_level=1`; subsequent leveling is allowed.
+Native factory-created newcomers are enrolled only from verified RNDBOT accounts
+and only when fresh and level 1.
+
+## Installation
+
+1. Build the updated AzerothAI application and start its runtime.
+2. Run `python3 deploy/playable/install-lifecycle.py --lab /path/to/lab` to review.
+3. Stop `ac-worldserver`.
+4. Repeat the command with `--apply`. It backs up auth, character and playerbot
+   databases, current Lua scripts, compose overrides and the dashboard state.
+5. Recreate only the world container with `docker compose up -d --no-deps ac-worldserver`.
+6. Restart the ALE relay to load priority delivery for permanent-death events.
+
+The guard is enabled by installing its Lua file, independently of the dashboard
+hardcore toggle. Remove the guard and recreate the world before intentionally
+switching back to non-hardcore play. Do not erase the registry to recycle deaths.
+
+## Verification and recovery
+
+Verify the lifecycle startup line, absence of lifecycle errors, zero retired
+GUIDs online, new reserve activations at level 1, and the native target count.
+The dashboard active count excludes unmanaged prototype entries in live mode.
+
+For rollback, stop the world and restore its prior Lua directory and compose
+override from the printed backup directory, then recreate the world container.
+The previous characters were never deleted. Database restoration is a separate
+operator action: it also rolls back gameplay since the backup timestamp.
+
+Run `python3 tests/lifecycle-lua.test.py` with `lupa` installed for isolated
+retirement, replay, protection and replacement-entry checks. Run
+`node scripts/test-core.mjs` for application tests.
diff --git a/scripts/ale-db-relay.mjs b/scripts/ale-db-relay.mjs
index a41822b..9535eab 100644
--- a/scripts/ale-db-relay.mjs
+++ b/scripts/ale-db-relay.mjs
@@ -104,7 +104,7 @@ async function deliverEvents(){
  FROM acore_auth.azerothai_event_outbox
  WHERE delivered_at IS NULL
  ${fresh.length?`AND id NOT IN (${fresh.map(row=>Number(row[0])).join(',')})`:''}
- ORDER BY CASE WHEN kind IN ('player.whisper','player.chat') AND created_at >= NOW() - INTERVAL 90 SECOND THEN 0 ELSE 1 END, id
+ ORDER BY CASE WHEN kind IN ('player.permanent-death','bridge.ready') THEN 0 WHEN kind IN ('player.whisper','player.chat') AND created_at >= NOW() - INTERVAL 90 SECOND THEN 1 ELSE 2 END, id
  LIMIT ${Math.max(1,EVENT_BATCH-fresh.length)}`);
  for(const [id,kindHex,payloadHex] of [...fresh,...batch]){
   const kind=Buffer.from(kindHex||'','hex').toString('utf8');
diff --git a/tests/hardcore.test.cjs b/tests/hardcore.test.cjs
index bb73298..7f7c203 100644
--- a/tests/hardcore.test.cjs
+++ b/tests/hardcore.test.cjs
@@ -3,6 +3,7 @@ const assert=require('node:assert/strict');
 const {execute}=require('../.test-build/service.js');
 const {seed}=require('../.test-build/seed.js');
 const {connectors}=require('../.test-build/connectors/index.js');
+const {applyAuthoritativeAleEvent}=require('../.test-build/service.js');
 
 class Store {
  constructor(){this.state=seed();}
@@ -10,6 +11,18 @@ class Store {
  async save(s,r){assert.equal(this.state.revision,r);s.revision=r+1;this.state=structuredClone(s);}
 }
 
+test('game lifecycle death closes identity once and preserves Zaku',async()=>{
+ const store=new Store();
+ const bot=store.state.bots.find(b=>b.id==='bot-6');
+ const payload={name:bot.name,isBot:true,characterGuid:99,accountId:2,deathId:'hardcore-99'};
+ await applyAuthoritativeAleEvent(store,'player.permanent-death',payload);
+ assert.equal(store.state.bots.find(b=>b.id===bot.id).status,'dead');
+ await applyAuthoritativeAleEvent(store,'player.permanent-death',payload);
+ assert.equal(store.state.events.filter(e=>e.kind==='death').length,1);
+ await applyAuthoritativeAleEvent(store,'player.permanent-death',{name:'Zaku',isBot:true,characterGuid:9,accountId:1});
+ assert.notEqual(store.state.bots.find(b=>b.name==='Zaku').status,'dead');
+});
+
 test('Zaku is a mortal persistent hero and hardcore starts enabled',()=>{
  const state=seed();
  const zaku=state.bots.find(b=>b.id==='hero-zaku');
diff --git a/tests/lifecycle-lua.test.py b/tests/lifecycle-lua.test.py
new file mode 100644
index 0000000..31d016c
--- /dev/null
+++ b/tests/lifecycle-lua.test.py
@@ -0,0 +1,117 @@
+"""Run with python3 after installing lupa; no live server or database involved."""
+from pathlib import Path
+from lupa import LuaRuntime
+
+lua = LuaRuntime()
+setup='''
+rows={{10,"Dead",1,0,"dead",2},{11,"Zaku",1,1,"active",5},
+      {12,"Fresh",2,0,"reserve",2},{13,"Human",3,0,"active",1},
+      {14,"Wronglevel",2,0,"reserve",2}}
+players={}; writes={}; removed={}; values={}; events={}; deaths=0
+function player(guid,name,account,level,dead)
+ local p={guid=guid,name=name,account=account,level=level,dead=dead}
+ function p:GetGUIDLow() return self.guid end
+ function p:GetName() return self.name end
+ function p:GetAccountId() return self.account end
+ function p:GetLevel() return self.level end
+ function p:GetRace() return self.race or 2 end
+ function p:IsDead() return self.dead end
+ players[name]=p; return p
+end
+function AuthDBQuery(sql)
+ if string.find(sql,'SELECT id FROM account',1,true) then
+  if string.find(sql,'id=99 ',1,true) then return nil end
+  return {GetUInt32=function() return 2 end}
+ end
+ local q={i=1}
+ function q:GetUInt32(n) return rows[self.i][n+1] end
+ function q:GetString(n) return rows[self.i][n+1] end
+ function q:NextRow() self.i=self.i+1;return self.i<=#rows end
+ return q
+end
+function CharDBQuery(sql) return {GetUInt32=function() return 0 end} end
+function AuthDBExecute(sql) table.insert(writes,sql) end
+mgr={}
+function mgr:Remove(p) table.insert(removed,p.guid);players[p.name]=nil end
+function mgr:SetValue(guid,key,value) values[guid..key]=value end
+function mgr:GetValue(guid,key) return values[guid..key] or 0 end
+function GetRandomPlayerbotMgr() return mgr end
+function GetPlayerByName(name) return players[name] end
+function GetPlayersInWorld() return players end
+function RegisterPlayerEvent(id,fn) events[id]=fn end
+function CreateLuaEvent(fn) tick=fn end
+function PrintError(text) end
+function PrintInfo(text) end
+function AzerothAIEmitPermanentDeath(p) deaths=deaths+1 end
+function AzerothAIEmitPlayerSnapshot(name) end
+player(10,"Dead",1,80,false)
+player(11,"Zaku",1,7,true)
+player(12,"Fresh",2,1,false)
+-- A mismatched account must never be managed, even if the GUID/name matches.
+player(13,"Human",99,20,true)
+player(14,"Wronglevel",2,55,false)
+'''
+lua.execute(setup)
+lua.execute((Path(__file__).parents[1] / 'ale/azerothai_lifecycle.lua').read_text())
+lua.execute('''
+assert(#removed==1 and removed[1]==10)
+assert(values['10logout']==1 and values['10add']==0)
+assert(players.Zaku and players.Human)
+assert(deaths==0)
+tick();assert(not players.Wronglevel)
+local fresh=players.Fresh
+events[8](8,nil,fresh);events[8](8,nil,fresh);events[6](6,nil,fresh)
+assert(deaths==1,'Repeated death events must be idempotent')
+tick();assert(not players.Fresh and values['12logout']==1)
+events[8](8,nil,players.Zaku);events[8](8,nil,players.Human)
+assert(deaths==1 and players.Zaku and players.Human)
+local before=#writes;tick();assert(#writes==before,'No per-second database churn')
+-- A retired identity accidentally logged in again must be evicted.
+player(10,'Dead',1,80,false);tick();assert(not players.Dead)
+player(15,'Factorynew',2,1,false);tick();assert(players.Factorynew)
+player(16,'Realhuman',99,1,true);tick();assert(players.Realhuman)
+assert(deaths==1)
+events[8](8,nil,players.Factorynew);tick();assert(not players.Factorynew)
+assert(deaths==2)
+local fast=player(17,'Fastlearner',2,1,false)
+events[3](3,fast);fast.level=2;tick();assert(players.Fastlearner)
+''')
+balanced=LuaRuntime()
+balanced.execute(setup)
+balanced.execute('''
+players={};rows={}
+for i=1,25 do
+ rows[#rows+1]={100+i,'Horde'..i,2,0,'active',2}
+ player(100+i,'Horde'..i,2,5,false)
+end
+rows[#rows+1]={201,'Alliancefresh',2,0,'reserve',1}
+rows[#rows+1]={202,'Hordefresh',2,0,'reserve',2}
+player(201,'Alliancefresh',2,1,false)
+player(202,'Hordefresh',2,1,false)
+''')
+balanced.execute((Path(__file__).parents[1] / 'ale/azerothai_lifecycle.lua').read_text())
+balanced.execute('''
+assert(players.Alliancefresh,'Underrepresented faction must fill its vacancy')
+assert(not players.Hordefresh,'Do not exceed 25 members of a faction')
+assert(values['202logout']==1)
+assert(deaths==0,'Faction deferral is not a death')
+''')
+returning=LuaRuntime()
+returning.execute(setup)
+returning.execute("""
+players={};rows={}
+for i=1,26 do
+ rows[#rows+1]={100+i,'Horde'..i,2,0,'active',2}
+ player(100+i,'Horde'..i,2,5,false)
+end
+rows[#rows+1]={999,'Zaku',2,1,'active',2}
+player(999,'Zaku',2,7,false)
+""")
+returning.execute((Path(__file__).parents[1] / 'ale/azerothai_lifecycle.lua').read_text())
+returning.execute("""
+local n=0;for _ in pairs(players) do n=n+1 end
+assert(n==25 and players.Zaku,'Returning population must obey faction cap and protect Zaku')
+assert(deaths==0,'Holding returning residents offline must not retire them')
+assert(values['125logout']==1 and values['126logout']==1)
+""")
+print('PASS: retirement, protection, level-1 entry, replay safety, and 25/25 faction balancing')

From 360f1649052f9a146b7819ad74dd55f1ad20741d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 22 Sep 2026 16:20:47 -0400
Subject: [PATCH 05/13] Allow level-55 Death Knights within race-based faction
 limits

---
 ale/azerothai_lifecycle.lua          | 16 ++++++++++------
 deploy/playable/install-lifecycle.py |  6 +++---
 docs/hardcore-replacement.md         | 10 +++++-----
 tests/lifecycle-lua.test.py          | 16 ++++++++++++++++
 4 files changed, 34 insertions(+), 14 deletions(-)

diff --git a/ale/azerothai_lifecycle.lua b/ale/azerothai_lifecycle.lua
index 6952d26..c6d3dfc 100644
--- a/ale/azerothai_lifecycle.lua
+++ b/ale/azerothai_lifecycle.lua
@@ -1,5 +1,5 @@
 -- Persistent hardcore retirement. The native random-bot manager fills vacancies
--- from its factory-created, unused level-1 reserve; identities are never reset.
+-- from its factory-created, unused starting-level reserve; identities are never reset.
 -- Install only after deploy/playable/install-lifecycle.py has seeded the registry.
 local residents = {}
 local ready = false
@@ -21,6 +21,10 @@ local function sqltext(value)
  return "CONVERT(UNHEX('"..(string.gsub(value,".",function(c) return string.format("%02X",string.byte(c)) end)).."') USING utf8mb4)"
 end
 
+local function startingLevel(player)
+ return player:GetClass()==6 and 55 or 1
+end
+
 local function enroll(player)
  local guid=player:GetGUIDLow()
  if unmanaged[guid] then return nil end
@@ -33,7 +37,7 @@ local function enroll(player)
  if not owned then unmanaged[guid]=true;return nil end
  local character=CharDBQuery("SELECT totaltime FROM characters WHERE guid="..guid.." AND account="..account)
  if not character then return nil end
- local state=(player:GetLevel()==1 and character:GetUInt32(0)<=60) and "reserve" or "blocked"
+ local state=(player:GetLevel()==startingLevel(player) and character:GetUInt32(0)<=60) and "reserve" or "blocked"
  local row={name=name,account=account,protected=false,state=state,race=player:GetRace()}
  residents[guid]=row
  AuthDBExecute("INSERT IGNORE INTO azerothai_lifecycle(guid,name,account_id,protected,state,race) VALUES ("..
@@ -130,17 +134,17 @@ local function enforce()
    if player:IsDead() then
     recordDeath(player)
    elseif row.state=="reserve" then
-    if (arrivals[guid] or player:GetLevel())~=1 then
+    if (arrivals[guid] or player:GetLevel())~=startingLevel(player) then
      row.state="blocked"
      AuthDBExecute("UPDATE azerothai_lifecycle SET state='blocked' WHERE guid="..guid.." AND state='reserve'")
-     PrintError("[AzerothAI] Replacement did not start at level 1: "..row.name)
+     PrintError("[AzerothAI] Replacement did not start at its class starting level: "..row.name)
     elseif faction(row) and counts[faction(row)]<TARGET_PER_FACTION then
      counts[faction(row)]=counts[faction(row)]+1
      row.state="active"
      online[guid]=true
-     AuthDBExecute("UPDATE azerothai_lifecycle SET state='active',entry_level=1,activated_at=COALESCE(activated_at,NOW()) WHERE guid="..guid.." AND state='reserve'")
+     AuthDBExecute("UPDATE azerothai_lifecycle SET state='active',entry_level="..startingLevel(player)..",activated_at=COALESCE(activated_at,NOW()) WHERE guid="..guid.." AND state='reserve'")
      if AzerothAIEmitPlayerSnapshot then AzerothAIEmitPlayerSnapshot(row.name) end
-     PrintInfo("[AzerothAI] New level-1 resident entered the world: "..row.name)
+     PrintInfo("[AzerothAI] New resident entered at class starting level: "..row.name)
     else
      -- A login already in flight must not push its faction over the target.
      mgr:Remove(player)
diff --git a/deploy/playable/install-lifecycle.py b/deploy/playable/install-lifecycle.py
index dedf758..a38a8e2 100644
--- a/deploy/playable/install-lifecycle.py
+++ b/deploy/playable/install-lifecycle.py
@@ -55,14 +55,14 @@ for guid, name, account, level, played, cls in characters:
         status = 'dead'
     elif bot and bot['status'] != 'retired':
         status = 'active'
-    elif int(level) == 1 and int(played) == 0 and int(cls) != 6:
+    elif int(level) == (55 if int(cls) == 6 else 1) and int(played) == 0:
         status = 'reserve'
     else:
         status = 'blocked'
     counts[status] = counts.get(status, 0) + 1
     rows.append((guid, name, account, int(protected), status))
 assert any(name.lower() == 'zaku' and protected for _, name, _, protected, _ in rows)
-assert counts.get('reserve', 0) >= counts.get('dead', 0), 'Insufficient unused level-1 reserve'
+assert counts.get('reserve', 0) >= counts.get('dead', 0), 'Insufficient unused starting-level reserve'
 print('Lifecycle plan:', json.dumps(counts), flush=True)
 if not args.apply:
     raise SystemExit(0)
@@ -119,7 +119,7 @@ for key in ['POLL_MS', 'PROTECTED', 'KNOWN_BOT_ACCOUNTS']:
 shutil.copy2(repo / 'ale/azerothai_lifecycle.lua', core / 'azerothai-lua/azerothai_lifecycle.lua')
 settings = {'AC_AI_PLAYERBOT_DISABLE_RANDOM_LEVELS': '1',
     'AC_AI_PLAYERBOT_RANDOMBOT_STARTING_LEVEL': '1',
-    'AC_AI_PLAYERBOT_DISABLE_DEATH_KNIGHT_LOGIN': '1'}
+    'AC_AI_PLAYERBOT_DISABLE_DEATH_KNIGHT_LOGIN': '0'}
 content = override.read_text()
 for key, value in settings.items():
     pattern = r'(?m)^(\s*)' + key + r':.*$'
diff --git a/docs/hardcore-replacement.md b/docs/hardcore-replacement.md
index e866b1a..24a3983 100644
--- a/docs/hardcore-replacement.md
+++ b/docs/hardcore-replacement.md
@@ -8,7 +8,7 @@ installation registry; human accounts are never included.
 
 The installer promotes unused manual-summoning reserve accounts into the native
 autonomous pool. The native random-bot manager maintains its configured population target using
-unused factory-created characters. Replacements start at level 1, with their
+unused factory-created characters. Replacements start at level 1 (Death Knights at level 55), with their
 own names and AzerothAI recipes/memories assigned when observed. This does not
 reset or resurrect a dead character. Duplicate death events are harmless.
 
@@ -16,15 +16,15 @@ The reserve is finite: this deployment began with 450 unused level-1 characters.
 This release does not create additional accounts or extend the factory reserve
 when it is exhausted. The population will fall below target if no eligible
 characters remain. Check `azerothai_lifecycle` state counts before extending it.
-Death Knights are excluded from new random logins because they do not start at
-level 1. Normal gameplay can still level a replacement after its initial entry.
+Death Knights are eligible and count toward their race’s faction, within the same
+25-per-faction cap. Their approved starting level is 55. Normal gameplay can still level a replacement after its initial entry.
 
 The guard allocates new arrivals against actual living faction counts, targeting
 25 Alliance and 25 Horde, including protected residents. It holds excess-faction
 reserves and excess returning residents offline without retiring them. Returning
-residents retain their progress and get priority over unused reserves. New activations record `entry_level=1`; subsequent leveling is allowed.
+residents retain their progress and get priority over unused reserves. New activations record `entry_level=1` or `entry_level=55` for Death Knights; subsequent leveling is allowed.
 Native factory-created newcomers are enrolled only from verified RNDBOT accounts
-and only when fresh and level 1.
+and only when fresh and at their class starting level.
 
 ## Installation
 
diff --git a/tests/lifecycle-lua.test.py b/tests/lifecycle-lua.test.py
index 31d016c..3c3af29 100644
--- a/tests/lifecycle-lua.test.py
+++ b/tests/lifecycle-lua.test.py
@@ -14,6 +14,7 @@ function player(guid,name,account,level,dead)
  function p:GetName() return self.name end
  function p:GetAccountId() return self.account end
  function p:GetLevel() return self.level end
+ function p:GetClass() return self.class or 1 end
  function p:GetRace() return self.race or 2 end
  function p:IsDead() return self.dead end
  players[name]=p; return p
@@ -114,4 +115,19 @@ assert(n==25 and players.Zaku,'Returning population must obey faction cap and pr
 assert(deaths==0,'Holding returning residents offline must not retire them')
 assert(values['125logout']==1 and values['126logout']==1)
 """)
+dk=LuaRuntime()
+dk.execute(setup)
+dk.execute("""
+players={};rows={{201,'AllianceDK',2,0,'reserve',1},{202,'HordeDK',2,0,'reserve',2}}
+local a=player(201,'AllianceDK',2,55,false);a.class=6;a.race=1
+local h=player(202,'HordeDK',2,55,false);h.class=6
+""")
+dk.execute((Path(__file__).parents[1] / 'ale/azerothai_lifecycle.lua').read_text())
+dk.execute("""
+assert(players.AllianceDK and players.HordeDK)
+local entries=0
+for _,q in pairs(writes) do if string.find(q,'entry_level=55',1,true) then entries=entries+1 end end
+assert(entries==2,'Death Knights must be audited at level 55')
+events[8](8,nil,players.HordeDK);tick();assert(not players.HordeDK and deaths==1)
+""")
 print('PASS: retirement, protection, level-1 entry, replay safety, and 25/25 faction balancing')

From ce6b38f3bb7b3f6b38eedcd00b382aaaaa8c9164 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 22 Sep 2026 16:30:45 -0400
Subject: [PATCH 06/13] Reconcile dashboard online presence against complete
 live roster

---
 ale/azerothai_bridge.lua |  9 +++++++++
 core/service.ts          | 28 +++++++++++++++++++++++-----
 core/types.ts            |  2 +-
 tests/hardcore.test.cjs  | 13 +++++++++++++
 4 files changed, 46 insertions(+), 6 deletions(-)

diff --git a/ale/azerothai_bridge.lua b/ale/azerothai_bridge.lua
index 9056345..2a59298 100644
--- a/ale/azerothai_bridge.lua
+++ b/ale/azerothai_bridge.lua
@@ -47,6 +47,11 @@ local function json_value(value)
  if value == nil then return "null" end
  if t == "boolean" then return value and "true" or "false" end
  if t == "number" then return tostring(value) end
+ if t == "table" then
+  local parts={}
+  for _,item in ipairs(value) do parts[#parts+1]=json_value(item) end
+  return "["..table.concat(parts,",").."]"
+ end
  return '"' .. escape_json(value) .. '"'
 end
 
@@ -187,12 +192,16 @@ function AzerothAIEmitSnapshots()
  local ok,players=pcall(function() return GetPlayersInWorld() end)
  if not ok or type(players)~="table" then return 0 end
  local emitted=0
+ local guids={}
  for _,player in pairs(players) do
   if is_playerbot(player) then
    emit("player.snapshot",player_payload(player))
+   guids[#guids+1]=player:GetGUIDLow()
    emitted=emitted+1
   end
  end
+ -- Use snapshot transport so roster reconciliation shares fresh-event priority.
+ emit("player.snapshot",{roster=true,observedAt=os.time(),characterGuids=guids})
  return emitted
 end
 
diff --git a/core/service.ts b/core/service.ts
index 9d0e392..b3308fb 100644
--- a/core/service.ts
+++ b/core/service.ts
@@ -72,6 +72,24 @@ function observedHardcoreDeath(s:State,b:Bot,observation:Observation){
 export async function applyAuthoritativeAleEvent(store:StateStore,kind:string,payload:Record<string,unknown>){
  let s=await store.load();
  const revision=s.revision;
+ // Complete world snapshots own presence once available; historical events
+ // must never bring disconnected residents back online.
+ if(kind==='player.snapshot' && payload.roster===true){
+  const at=payload.observedAt;
+  const guids=payload.characterGuids;
+  if(typeof at!=='number'||!Number.isFinite(at)||!Array.isArray(guids)||!guids.every(g=>Number.isInteger(g)&&g>0))throw new Error('Invalid authoritative roster');
+  if(at<=(s.aleRosterAt??0))return {matched:false,stale:true};
+  const online=new Set(guids);
+  for(const bot of s.bots){
+   if(bot.status==='dead'||bot.status==='retired')continue;
+   const present=bot.autonomy?.managed && online.has(bot.autonomy.characterGuid);
+   bot.status=present?'online':'offline';
+   bot.simulationBand=present?'background':'dormant';
+  }
+  s.aleRosterAt=at;
+  await store.save(s,revision);
+  return {matched:true,roster:true};
+ }
  if(kind==='bridge.ready'){
   let changed=false;
   for(const bot of s.bots){
@@ -103,7 +121,7 @@ export async function applyAuthoritativeAleEvent(store:StateStore,kind:string,pa
   const isZaku=name.toLowerCase()==='zaku';
   b={
    id:isZaku?'hero-zaku':`live-${crypto.randomUUID()}`,
-   name,role,race,level,zone,status:'online',
+   name,role,race,level,zone,status:s.aleRosterAt?'offline':'online',
    tier:isZaku?'hero':'resident',mortal:true,plotArmorHpFloor:isZaku?1:0,
    simulationBand:'background',
    routine:{wakeHour:isZaku?10:7,sleepHour:isZaku?3:23,preferredZones:[zone]},
@@ -137,19 +155,19 @@ export async function applyAuthoritativeAleEvent(store:StateStore,kind:string,pa
  if(zone)b.zone=zone;
 
  if(kind==='player.login'){
-  b.status='online';
+  if(!s.aleRosterAt)b.status='online';
   b.simulationBand='foreground';
   event(s,'lifecycle',`${b.name} logged into the authoritative AzerothCore world.`,b.id);
  }else if(kind==='player.logout'){
-  b.status='offline';
+  if(!s.aleRosterAt)b.status='offline';
   b.simulationBand='dormant';
   event(s,'lifecycle',`${b.name} logged out of the authoritative AzerothCore world.`,b.id);
  }else if(kind==='player.zone'||kind==='player.map'){
-  if(b.status==='offline')b.status='online';
+  if(!s.aleRosterAt&&b.status==='offline')b.status='online';
   b.simulationBand='foreground';
   event(s,'lifecycle',`${b.name} is now in ${b.zone} (authoritative ALE observation).`,b.id);
  }else if(kind==='player.snapshot'){
-  if(b.status==='offline')b.status='online';
+  if(!s.aleRosterAt&&b.status==='offline')b.status='online';
   if(b.simulationBand==='dormant')b.simulationBand='background';
  }else if(kind==='player.level'){
   const text=`I reached level ${b.level} while living in ${b.zone}.`;
diff --git a/core/types.ts b/core/types.ts
index 088adcd..d247abb 100644
--- a/core/types.ts
+++ b/core/types.ts
@@ -18,7 +18,7 @@ export type PopulationSettings = {defaultZoneTarget:number; zoneMax:number; serv
 export type BrainRouterSettings = {enabled:boolean; residentModel:string; heroModel:string; backgroundUseLLM:boolean; residentMemoryLimit:number; heroMemoryLimit:number; residentMaxTokens:number; heroMaxTokens:number};
 export type WorldTrigger = {id:string; kind:'zone-change'|'interaction'|'time'|'manual'; zone:string; at:string; playerName?:string; detail?:string};
 export type PopulationPlan = {id:string; trigger:WorldTrigger; target:number; activeBefore:number; requested:number; capacity:number; selectedBotIds:string[]; rejectedReasons:string[]; createdAt:string};
-export type State = {revision:number; bots:Bot[]; homes:Home[]; recipes:Recipe[]; events:RealmEvent[]; sequence:number; settings:{connector:'simulation'|'azerothcore'; provider:'deterministic'|'ollama'|'openai-compatible'; model:string; brains:BrainRouterSettings; hardcore:HardcoreSettings; population:PopulationSettings}; director:{experience:string; zone:string; playerName:string; brief:string}; population:{lastPlan?:PopulationPlan}; operations:Record<string,{started:number; botId:string}>};
+export type State = {revision:number; aleRosterAt?:number; bots:Bot[]; homes:Home[]; recipes:Recipe[]; events:RealmEvent[]; sequence:number; settings:{connector:'simulation'|'azerothcore'; provider:'deterministic'|'ollama'|'openai-compatible'; model:string; brains:BrainRouterSettings; hardcore:HardcoreSettings; population:PopulationSettings}; director:{experience:string; zone:string; playerName:string; brief:string}; population:{lastPlan?:PopulationPlan}; operations:Record<string,{started:number; botId:string}>};
 export type DeathSignal = {id:string; at:string; cause:string; killer?:string; zone?:string; verified:boolean};
 export type Observation = {zone:string; level:number; availableActions:Activity[]; summary:string; alive:boolean; death?:DeathSignal};
 export interface GameConnector {id:string; health():Promise<{ok:boolean; detail:string}>; observe(bot:Bot):Promise<Observation>; lifecycle(bot:Bot,action:'spawn'|'pause'|'resume'|'despawn'|'retire',requestId:string):Promise<void>; decide(bot:Bot,decision:Decision,requestId:string):Promise<{summary:string;zone?:string}>;}
diff --git a/tests/hardcore.test.cjs b/tests/hardcore.test.cjs
index 7f7c203..7b4ff78 100644
--- a/tests/hardcore.test.cjs
+++ b/tests/hardcore.test.cjs
@@ -79,3 +79,16 @@ test('unverified bridge death fails safe without erasing identity',async()=>{
   assert.equal(bot.death,undefined);
  }finally{connectors.simulation=old;}
 });
+
+ test('complete roster clears stale presence and historical events cannot restore it',async()=>{
+ const store=new Store();
+ const payload={name:'Rosterbot',isBot:true,characterGuid:123,accountId:2,className:'Death Knight',raceName:'Orc',level:55};
+ await applyAuthoritativeAleEvent(store,'player.snapshot',payload);
+ await applyAuthoritativeAleEvent(store,'player.snapshot',{roster:true,observedAt:100,characterGuids:[123]});
+ assert.equal(store.state.bots.filter(b=>b.status==='online').length,1);
+ await applyAuthoritativeAleEvent(store,'player.snapshot',{roster:true,observedAt:101,characterGuids:[]});
+ for(const kind of ['player.login','player.snapshot','player.zone'])await applyAuthoritativeAleEvent(store,kind,payload);
+ assert.equal(store.state.bots.filter(b=>b.status==='online').length,0);
+ await applyAuthoritativeAleEvent(store,'player.snapshot',{roster:true,observedAt:100,characterGuids:[123]});
+ assert.equal(store.state.bots.filter(b=>b.status==='online').length,0);
+ });

From ee8161eca25362ceabc9359ed20ea78e9e0aefb7 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 22 Sep 2026 17:10:15 -0400
Subject: [PATCH 07/13] Enable bounded proximity conversations and confirmed
 social memories

---
 ale/azerothai_bridge.lua          | 19 ++++++++++++++++-
 app/api/bridge/ale/event/route.ts |  4 +++-
 core/conversation-store.ts        | 29 +++++++++++++++++++++++++-
 core/conversation.ts              | 34 +++++++++++++++++++++++++------
 tests/conversation.test.cjs       | 34 +++++++++++++++++++++++++++++++
 5 files changed, 111 insertions(+), 9 deletions(-)

diff --git a/ale/azerothai_bridge.lua b/ale/azerothai_bridge.lua
index 2a59298..d3789da 100644
--- a/ale/azerothai_bridge.lua
+++ b/ale/azerothai_bridge.lua
@@ -188,6 +188,7 @@ CreateLuaEvent(function() poll() end, POLL_MS, 0)
 -- Keep AzerothAI grounded in real online Playerbots even when no human is logged in.
 -- Expose a safe global refresh hook too, so the autonomy worker can explicitly
 -- request a fresh authoritative snapshot if the periodic timer ever stalls.
+local socialLast={}
 function AzerothAIEmitSnapshots()
  local ok,players=pcall(function() return GetPlayersInWorld() end)
  if not ok or type(players)~="table" then return 0 end
@@ -201,7 +202,23 @@ function AzerothAIEmitSnapshots()
   end
  end
  -- Use snapshot transport so roster reconciliation shares fresh-event priority.
- emit("player.snapshot",{roster=true,observedAt=os.time(),characterGuids=guids})
+ local roster={roster=true,observedAt=os.time(),characterGuids=guids}
+ local ordered={}
+ for _,p in pairs(players) do if is_playerbot(p) then ordered[#ordered+1]=p end end
+ table.sort(ordered,function(a,b) return (socialLast[a:GetGUIDLow()] or 0)<(socialLast[b:GetGUIDLow()] or 0) end)
+ for _,p in ipairs(ordered) do
+  if not p:IsDead() and not p:IsInCombat() and os.time()-(socialLast[p:GetGUIDLow()] or 0)>600 then
+   for _,q in pairs(p:GetPlayersInRange(25) or {}) do
+    if q:GetGUIDLow()~=p:GetGUIDLow() and is_playerbot(q) and not q:IsDead() and not q:IsInCombat() and p:GetTeam()==q:GetTeam() and p:GetPhaseMask()==q:GetPhaseMask() and os.time()-(socialLast[q:GetGUIDLow()] or 0)>600 then
+     roster.socialA=p:GetName();roster.socialB=q:GetName();roster.zoneName=area_name(p:GetZoneId())
+     socialLast[p:GetGUIDLow()]=os.time();socialLast[q:GetGUIDLow()]=os.time()
+     break
+    end
+   end
+  end
+  if roster.socialA then break end
+ end
+ emit("player.snapshot",roster)
  return emitted
 end
 
diff --git a/app/api/bridge/ale/event/route.ts b/app/api/bridge/ale/event/route.ts
index 6437f5d..48847ca 100644
--- a/app/api/bridge/ale/event/route.ts
+++ b/app/api/bridge/ale/event/route.ts
@@ -2,7 +2,7 @@ import { env } from 'cloudflare:workers';
 import { z } from 'zod';
 import { requireAleBridge } from '@/core/ale-auth';
 import { recordAleEvent } from '@/core/ale-store';
-import { queueConversationEvent } from '@/core/conversation-store';
+import { queueSocialEncounter,queueConversationEvent } from '@/core/conversation-store';
 import { D1Store } from '@/core/store';
 import { applyAuthoritativeAleEvent,execute } from '@/core/service';
 import type { RuntimeConfig } from '@/core/types';
@@ -42,6 +42,8 @@ export async function POST(request:Request){
    await queueConversationEvent(env.DB!,body.kind,body.payload);
   }
 
+  if(body.kind==='player.snapshot'&&body.payload.roster===true)await queueSocialEncounter(env.DB!,body.payload);
+
   const store=new D1Store();
   if(STATEFUL_EVENTS.has(body.kind)){
    await applyAuthoritativeAleEvent(store,body.kind,body.payload);
diff --git a/core/conversation-store.ts b/core/conversation-store.ts
index 746bcc9..4a2cb8a 100644
--- a/core/conversation-store.ts
+++ b/core/conversation-store.ts
@@ -1,6 +1,7 @@
 export type ConversationChannel='say'|'whisper';
 
 export type ConversationRequest={
+ socialTurn?:0|1;
  id:string;
  createdAt:string;
  speakerName:string;
@@ -79,7 +80,7 @@ export async function leaseConversation(db:D1Database):Promise<ConversationReque
   .bind(staleBefore).run();
 
  const row=await db.prepare(`SELECT id,created_at,speaker_name,message,channel,zone_name,receiver,selected_player,nearby_bots,status,attempts
-  FROM conversation_requests WHERE status='pending' ORDER BY created_at LIMIT 1`).first<any>();
+  FROM conversation_requests WHERE status='pending' ORDER BY CASE WHEN channel LIKE 'social-%' THEN 1 ELSE 0 END,created_at LIMIT 1`).first<any>();
  if(!row)return null;
 
  const startedAt=new Date().toISOString();
@@ -89,6 +90,7 @@ export async function leaseConversation(db:D1Database):Promise<ConversationReque
  if(updated.meta.changes!==1)return null;
 
  return {
+  socialTurn:row.channel==='social-start'?0:row.channel==='social-reply'?1:undefined,
   id:row.id,
   createdAt:row.created_at,
   speakerName:row.speaker_name,
@@ -141,3 +143,28 @@ export async function pendingDeliveries(db:D1Database){
  }
  return deliveries;
 }
+
+// One autonomous exchange per two-minute bucket; human chat keeps priority.
+export async function queueSocialEncounter(db:D1Database,payload:Record<string,unknown>){
+ const a=text(payload,'socialA',40),b=text(payload,'socialB',40);
+ const at=Number(payload.observedAt);
+ if(!a||!b||a===b||!Number.isFinite(at)||Math.abs(Date.now()/1000-at)>60)return;
+ await ensure(db);
+ const now=new Date().toISOString();
+ const cutoff=new Date(Date.now()-10*60_000).toISOString();
+ const id='social-'+Math.floor(Date.now()/120_000);
+ await db.prepare(`INSERT OR IGNORE INTO conversation_requests
+ (id,created_at,speaker_name,message,channel,zone_name,receiver,selected_player,nearby_bots,status,attempts)
+ SELECT ?,?,?,?,'social-start',?,?,?,?,'pending',0
+ WHERE NOT EXISTS (SELECT 1 FROM conversation_requests WHERE status IN ('pending','processing','awaiting_delivery'))
+ AND NOT EXISTS (SELECT 1 FROM conversation_requests WHERE channel LIKE 'social-%' AND created_at>? AND (speaker_name IN (?,?) OR selected_player IN (?,?)))`)
+ .bind(id,now,b,'Initiate a brief friendly in-world conversation with your nearby companion.',text(payload,'zoneName',120),a,a,b,cutoff,a,b,a,b).run();
+}
+
+export async function queueSocialReply(db:D1Database,request:ConversationRequest,botName:string,reply:string){
+ if(request.socialTurn!==0)return;
+ await db.prepare(`INSERT OR IGNORE INTO conversation_requests
+ (id,created_at,speaker_name,message,channel,zone_name,receiver,selected_player,nearby_bots,status,attempts)
+ VALUES (?,?,?,?,'social-reply',?,?,?,?,'pending',0)`)
+ .bind(request.id+':reply',new Date().toISOString(),botName,reply,request.zoneName,request.speakerName,request.speakerName,botName).run();
+}
diff --git a/core/conversation.ts b/core/conversation.ts
index 8d59f70..5539772 100644
--- a/core/conversation.ts
+++ b/core/conversation.ts
@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { queueAleCommand } from './ale-store';
 import { luaString } from './ale';
-import { cleanupConversations,completeConversation,failConversation,leaseConversation,awaitDelivery,pendingDeliveries,type ConversationRequest } from './conversation-store';
+import { queueSocialReply,cleanupConversations,completeConversation,failConversation,leaseConversation,awaitDelivery,pendingDeliveries,type ConversationRequest } from './conversation-store';
 import type { Bot,RealmEvent,RuntimeConfig,State,StateStore } from './types';
 
 const replySchema=z.object({reply:z.string().min(1).max(500)}).strict();
@@ -20,7 +20,7 @@ function byName(state:State,name:string){
  if(!lower)return undefined;
  return state.bots.find(bot=>
   bot.autonomy?.managed===true&&
-  bot.status!=='dead'&&bot.status!=='retired'&&
+  bot.status==='online'&&
   bot.name.toLowerCase()===lower
  );
 }
@@ -73,7 +73,7 @@ async function modelReply(bot:Bot,request:ConversationRequest,state:State,config
    content:JSON.stringify({
     speaker:request.speakerName,
     channel:request.channel,
-    message:request.message,
+    message:request.socialTurn===0?'Start a conversation with '+request.speakerName+' about your current surroundings or goals. They have not spoken yet.':request.message,
     currentZone:request.zoneName||bot.zone,
     identity:{name:bot.name,race:bot.race,role:bot.role,tier:bot.tier},
     personality:bot.personality,
@@ -105,11 +105,15 @@ async function modelReply(bot:Bot,request:ConversationRequest,state:State,config
  return cleanReply(replySchema.parse(JSON.parse(raw)).reply);
 }
 
-function compileReply(botName:string,speakerName:string,reply:string,channel:'say'|'whisper'){
+function compileReply(botName:string,speakerName:string,reply:string,channel:'say'|'whisper',social=false){
  const source=[
   `local bot=GetPlayerByName(${luaString(botName)})`,
   'if not bot then error("Conversation bot is not online") end'
  ];
+ if(social){
+  source.push(`local peer=GetPlayerByName(${luaString(speakerName)})`);
+  source.push('if not peer or bot:IsDead() or peer:IsDead() or bot:IsInCombat() or peer:IsInCombat() or bot:GetMapId()~=peer:GetMapId() or bot:GetPhaseMask()~=peer:GetPhaseMask() or bot:GetTeam()~=peer:GetTeam() or bot:GetDistance(peer)>25 then error("Social pair is no longer available nearby") end');
+ }
  if(channel==='whisper'){
   source.push(`local receiver=GetPlayerByName(${luaString(speakerName)})`);
   source.push('if not receiver then error("Conversation player is not online") end');
@@ -136,6 +140,19 @@ async function remember(store:StateStore,botId:string,request:ConversationReques
    at:new Date().toISOString()
   });
   bot.memories=bot.memories.slice(-100);
+  if(request.socialTurn===1){
+   const peer=byName(state,request.speakerName);
+   if(peer){
+    peer.memories.push({id:request.id,text:`I said to ${bot.name}: "${request.message.slice(0,180)}" They replied: "${reply.slice(0,180)}"`,importance:6,source:'observation',at:new Date().toISOString()});
+    peer.memories=peer.memories.slice(-100);
+    for(const [from,to] of [[bot,peer],[peer,bot]]){
+     const existing=from.relationships.find(r=>r.targetId===to.id);
+     if(existing)existing.note='We have spoken together in person.';
+     else from.relationships.push({targetId:to.id,affinity:0,note:'We have spoken together in person.'});
+     from.relationships=from.relationships.slice(-100);
+    }
+   }
+  }
   bot.simulationBand='foreground';
   realmEvent(state,'memory',`${bot.name} had a live conversation with ${request.speakerName}.`,bot.id);
   try{
@@ -150,16 +167,21 @@ async function remember(store:StateStore,botId:string,request:ConversationReques
 export async function runConversationTick(store:StateStore,db:D1Database,config:RuntimeConfig){
  for(const delivery of await pendingDeliveries(db)){
   if(delivery.status==='completed'){
-   await remember(store,delivery.botId,delivery.request,delivery.reply);
+   if(delivery.request.socialTurn!==0)await remember(store,delivery.botId,delivery.request,delivery.reply);
+   const state=await store.load();
+   const speaker=state.bots.find(b=>b.id===delivery.botId);
+   if(speaker)await queueSocialReply(db,delivery.request,speaker.name,delivery.reply);
    await completeConversation(db,delivery.request.id,JSON.stringify({commandId:delivery.commandId,delivered:true}));
   }else if(delivery.status==='failed'){
    await failConversation(db,delivery.request.id,delivery.error||'Game rejected conversation delivery');
   }
  }
+ await cleanupConversations(db);
  const request=await leaseConversation(db);
  if(!request)return {ok:true,ran:false,reason:'No player conversation waiting'};
 
  try{
+  if(request.socialTurn!==undefined&&Date.now()-Date.parse(request.createdAt)>120_000)throw new Error('Social encounter expired');
   const state=await store.load();
   const bot=chooseTarget(state,request);
   if(!bot){
@@ -171,7 +193,7 @@ export async function runConversationTick(store:StateStore,db:D1Database,config:
   reply=cleanReply(reply);
   if(!reply)throw new Error('Conversation reply was empty');
 
-  const command=await queueAleCommand(db,compileReply(bot.name,request.speakerName,reply,request.channel));
+  const command=await queueAleCommand(db,compileReply(bot.name,request.speakerName,reply,request.channel,request.socialTurn!==undefined));
   await awaitDelivery(db,request,bot.id,reply,command.id);
   await cleanupConversations(db);
 
diff --git a/tests/conversation.test.cjs b/tests/conversation.test.cjs
index b5e3bce..389976e 100644
--- a/tests/conversation.test.cjs
+++ b/tests/conversation.test.cjs
@@ -39,3 +39,37 @@ test('conversation failure, queued delivery, confirmed memory and replay safety'
   assert.equal(failed,'Bot offline');assert.equal(bot.memories.length,1);
  }finally{global.fetch=originalFetch;}
 });
+
+test('social exchanges remember both residents only after confirmed reply and replays are harmless',async()=>{
+ const a={id:'a',name:'A',status:'online',autonomy:{managed:true},memories:[],relationships:[],personality:{},race:'Orc',role:'Warrior'};
+ const b={...a,id:'b',name:'B',memories:[],relationships:[]};
+ const state={revision:0,sequence:0,events:[],bots:[a,b],settings:{provider:'ollama',model:'test',brains:{enabled:false,residentMemoryLimit:5,residentMaxTokens:100}}};
+ const store={load:async()=>state,save:async()=>{}};
+ const request={id:'social-test',createdAt:new Date().toISOString(),socialTurn:0,speakerName:'B',selectedPlayer:'A',message:'Initiate',channel:'say',nearbyBots:['B']};
+ let pending=request,deliveries=[],followups=0,source='';
+ queue.pendingDeliveries=async()=>deliveries;
+ queue.leaseConversation=async()=>{const r=pending;pending=null;return r;};
+ queue.cleanupConversations=async()=>{};
+ queue.completeConversation=async()=>{};
+ queue.failConversation=async()=>{};
+ queue.awaitDelivery=async(_db,r,botId,reply,commandId)=>{deliveries=[{request:r,botId,reply,commandId,status:'pending'}];};
+ queue.queueSocialReply=async(_db,r,name,reply)=>{if(r.socialTurn===0){followups++;pending={...r,id:r.id+':reply',socialTurn:1,speakerName:name,selectedPlayer:'B',message:reply};}};
+ ale.queueAleCommand=async(_db,s)=>{source=s;return {id:'cmd'};};
+ const originalFetch=global.fetch;
+ global.fetch=async()=>({ok:true,json:async()=>({message:{content:'{"reply":"How is the hunt going?"}'}})});
+ try{
+  await runConversationTick(store,{}, {LLM_URL:'http://model'});
+  assert.match(source,/GetDistance\(peer\)>25/);
+  assert.match(source,/GetTeam/);
+  assert.equal(a.memories.length,0);
+  deliveries[0].status='completed';
+  await runConversationTick(store,{}, {LLM_URL:'http://model'});
+  assert.equal(followups,1);assert.equal(a.memories.length,0);
+  deliveries[0].status='completed';
+  await runConversationTick(store,{},{});
+  assert.equal(a.memories.length,1);assert.equal(b.memories.length,1);
+  assert.equal(a.relationships[0].targetId,'b');assert.equal(b.relationships[0].targetId,'a');
+  await runConversationTick(store,{},{});
+  assert.equal(a.memories.length,1);assert.equal(b.memories.length,1);assert.equal(followups,1);
+ }finally{global.fetch=originalFetch;}
+});

From b0a661f425fb80d8875d3e4806674051513c34a1 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 22 Sep 2026 17:12:21 -0400
Subject: [PATCH 08/13] Document autonomous conversation bounds and memory
 storage

---
 docs/bot-conversations.md | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 docs/bot-conversations.md

diff --git a/docs/bot-conversations.md b/docs/bot-conversations.md
new file mode 100644
index 0000000..b79505e
--- /dev/null
+++ b/docs/bot-conversations.md
@@ -0,0 +1,24 @@
+# Autonomous conversations
+
+The live bridge proposes nearby, same-faction bot pairs within 25 yards. Both
+must be alive, out of combat and in the same phase. Opportunities ride the fresh
+roster snapshot transport. The database admits at most one exchange per two-minute
+clock bucket and enforces ten minutes between social requests involving a bot.
+Human requests take queue priority. Ordinary bot chatter does not trigger replies.
+
+An exchange consists of a model-generated opening and one model-generated reply.
+Each delivery rechecks distance, faction, phase, life and combat state in the game.
+Expired requests and pairs that have moved apart are cancelled. No characters are
+teleported or held in place for conversations.
+
+Only a confirmed reply creates reciprocal observation memories and neutral
+acquaintance records. This does not invent friendship or change affinity based
+solely on speaking. Replay IDs prevent duplicate memories. Each resident retains
+at most 100 memories and 100 relationship records on this path. Completed and
+failed conversation requests are pruned after 24 hours; character memorials and
+other game/event history have separate retention policies.
+
+Memories and relationships are stored in `realm_state.payload` in the application's
+D1 SQLite database under `.wrangler/state/v3/d1` in the Ubuntu deployment. This
+uses the VM's disk, backed by the host PC's storage. The per-resident memory limit
+is not a total disk quota: additional identities and other logs can still grow.

From 5bee808492ccda26485c0a04097d90b4a35d40a4 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 22 Sep 2026 17:13:19 -0400
Subject: [PATCH 09/13] Prefer stationary social pairs and deliver roster
 before individual snapshots

---
 ale/azerothai_bridge.lua  | 8 +++++---
 docs/bot-conversations.md | 2 +-
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/ale/azerothai_bridge.lua b/ale/azerothai_bridge.lua
index d3789da..9f6062d 100644
--- a/ale/azerothai_bridge.lua
+++ b/ale/azerothai_bridge.lua
@@ -196,7 +196,6 @@ function AzerothAIEmitSnapshots()
  local guids={}
  for _,player in pairs(players) do
   if is_playerbot(player) then
-   emit("player.snapshot",player_payload(player))
    guids[#guids+1]=player:GetGUIDLow()
    emitted=emitted+1
   end
@@ -207,9 +206,9 @@ function AzerothAIEmitSnapshots()
  for _,p in pairs(players) do if is_playerbot(p) then ordered[#ordered+1]=p end end
  table.sort(ordered,function(a,b) return (socialLast[a:GetGUIDLow()] or 0)<(socialLast[b:GetGUIDLow()] or 0) end)
  for _,p in ipairs(ordered) do
-  if not p:IsDead() and not p:IsInCombat() and os.time()-(socialLast[p:GetGUIDLow()] or 0)>600 then
+  if not p:IsDead() and not p:IsInCombat() and not p:IsMoving() and os.time()-(socialLast[p:GetGUIDLow()] or 0)>600 then
    for _,q in pairs(p:GetPlayersInRange(25) or {}) do
-    if q:GetGUIDLow()~=p:GetGUIDLow() and is_playerbot(q) and not q:IsDead() and not q:IsInCombat() and p:GetTeam()==q:GetTeam() and p:GetPhaseMask()==q:GetPhaseMask() and os.time()-(socialLast[q:GetGUIDLow()] or 0)>600 then
+    if q:GetGUIDLow()~=p:GetGUIDLow() and is_playerbot(q) and not q:IsDead() and not q:IsInCombat() and not q:IsMoving() and p:GetDistance(q)<=15 and p:GetTeam()==q:GetTeam() and p:GetPhaseMask()==q:GetPhaseMask() and os.time()-(socialLast[q:GetGUIDLow()] or 0)>600 then
      roster.socialA=p:GetName();roster.socialB=q:GetName();roster.zoneName=area_name(p:GetZoneId())
      socialLast[p:GetGUIDLow()]=os.time();socialLast[q:GetGUIDLow()]=os.time()
      break
@@ -219,6 +218,9 @@ function AzerothAIEmitSnapshots()
   if roster.socialA then break end
  end
  emit("player.snapshot",roster)
+ for _,player in pairs(players) do
+  if is_playerbot(player) then emit("player.snapshot",player_payload(player)) end
+ end
  return emitted
 end
 
diff --git a/docs/bot-conversations.md b/docs/bot-conversations.md
index b79505e..ce88054 100644
--- a/docs/bot-conversations.md
+++ b/docs/bot-conversations.md
@@ -1,6 +1,6 @@
 # Autonomous conversations
 
-The live bridge proposes nearby, same-faction bot pairs within 25 yards. Both
+The live bridge proposes nearby, same-faction stationary bot pairs within 15 yards. Delivery allows up to 25 yards. Both
 must be alive, out of combat and in the same phase. Opportunities ride the fresh
 roster snapshot transport. The database admits at most one exchange per two-minute
 clock bucket and enforces ten minutes between social requests involving a bot.

From 46935c791e12dbdc04235c07c55aac94ffe8413b Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 22 Sep 2026 17:43:07 -0400
Subject: [PATCH 10/13] Add social feed, cooperative parties, guild goals, and
 operations recovery

---
 ale/azerothai_bridge.lua                 |  55 ++++++++++-
 app/api/operations/route.ts              |  25 +++++
 app/community-panel.tsx                  |  23 +++++
 app/page.tsx                             |   5 +-
 core/autonomy.ts                         |   2 +
 core/community.ts                        | 118 +++++++++++++++++++++++
 core/conversation.ts                     |  10 +-
 core/service.ts                          |  10 ++
 core/types.ts                            |   8 +-
 core/validation.ts                       |   3 +
 deploy/playable/install-user-recovery.py |  42 ++++++++
 deploy/playable/windows-recovery.ps1     |  32 ++++++
 docs/community-and-operations.md         |  59 ++++++++++++
 scripts/operations-agent.py              |  54 +++++++++++
 scripts/test-core.mjs                    |   2 +-
 tests/community.test.cjs                 |  39 ++++++++
 tests/conversation.test.cjs              |   2 +
 17 files changed, 477 insertions(+), 12 deletions(-)
 create mode 100644 app/api/operations/route.ts
 create mode 100644 app/community-panel.tsx
 create mode 100644 core/community.ts
 create mode 100644 deploy/playable/install-user-recovery.py
 create mode 100644 deploy/playable/windows-recovery.ps1
 create mode 100644 docs/community-and-operations.md
 create mode 100644 scripts/operations-agent.py
 create mode 100644 tests/community.test.cjs

diff --git a/ale/azerothai_bridge.lua b/ale/azerothai_bridge.lua
index 9f6062d..98c3a33 100644
--- a/ale/azerothai_bridge.lua
+++ b/ale/azerothai_bridge.lua
@@ -112,6 +112,9 @@ local function player_payload(player)
   raceName=player:GetRaceAsString() or tostring(player:GetRace()),
   className=player:GetClassAsString() or tostring(player:GetClass()),
   healthPct=player:GetHealthPct(),
+  observedAt=os.time(),team=player:GetTeam(),x=player:GetX(),y=player:GetY(),
+  guildId=player:GetGuildId(),guildName=player:GetGuildName() or "",guildRank=player:GetGuildRank(),
+  inCombat=player:IsInCombat(),
   isBot=isBot
  }
 end
@@ -138,11 +141,22 @@ local function nearby_bot_names(player)
  return table.concat(names,",")
 end
 
+local function world_payload(player)
+ local p=player_payload(player)
+ local g=player:GetGroup()
+ p.groupId=g and tostring(g:GetGUID()) or ""
+ local members={}
+ if g then for _,m in pairs(g:GetMembers()) do members[#members+1]=m:GetName() end end
+ p.groupNames=table.concat(members,",")
+ p.nearbyBots=nearby_bot_names(player)
+ return p
+end
+
 function AzerothAIEmitPlayerSnapshot(name)
  if not name or name == "" then return 0 end
  local ok,player=pcall(function() return GetPlayerByName(name) end)
  if not ok or not player or not is_playerbot(player) then return 0 end
- emit("player.snapshot",player_payload(player))
+ emit("player.snapshot",world_payload(player))
  return 1
 end
 
@@ -219,7 +233,7 @@ function AzerothAIEmitSnapshots()
  end
  emit("player.snapshot",roster)
  for _,player in pairs(players) do
-  if is_playerbot(player) then emit("player.snapshot",player_payload(player)) end
+  if is_playerbot(player) then emit("player.snapshot",world_payload(player)) end
  end
  return emitted
 end
@@ -382,3 +396,40 @@ end
 
 emit("bridge.ready",{pollMs=POLL_MS,protectedCharacter=PROTECTED})
 PrintInfo("[AzerothAI] ALE bridge loaded; durable DB command polling every " .. tostring(POLL_MS) .. " ms")
+
+local completedQuests={}
+local helpedAt={}
+local function cooperative_event(a,b,kind,key,quest)
+ emit("player.snapshot",{cooperation=kind,evidenceId=key,characterGuid=a:GetGUIDLow(),peerGuid=b:GetGUIDLow(),observedAt=os.time(),questId=quest or 0})
+end
+RegisterPlayerEvent(54,function(event,player,quest)
+ if not is_playerbot(player) then return end
+ local q=quest:GetId()
+ completedQuests[player:GetGUIDLow()..":"..q]=os.time()
+ local g=player:GetGroup();if not g then return end
+ for _,other in pairs(g:GetMembers()) do
+  if other~=player and is_playerbot(other) and player:GetDistance(other)<=35 then
+   local stamp=completedQuests[other:GetGUIDLow()..":"..q]
+   if stamp and os.time()-stamp<300 then
+    local a,b=player:GetGUIDLow(),other:GetGUIDLow()
+    cooperative_event(player,other,"quest","quest:"..math.min(a,b)..":"..math.max(a,b)..":"..q..":"..math.floor(os.time()/86400),q)
+   end
+  end
+ end
+end)
+RegisterPlayerEvent(7,function(event,player,killed)
+ if not is_playerbot(player) then return end
+ local g=player:GetGroup();if not g then return end
+ for _,other in pairs(g:GetMembers()) do
+  if other~=player and is_playerbot(other) and not other:IsDead() and other:IsInCombat() and other:GetVictim() and other:GetVictim():GetGUID()==killed:GetGUID() and player:GetDistance(other)<=35 then
+   local a,b=player:GetGUIDLow(),other:GetGUIDLow();local key=math.min(a,b)..":"..math.max(a,b)
+   if os.time()-(helpedAt[key] or 0)>300 then
+    helpedAt[key]=os.time();cooperative_event(player,other,"assist","assist:"..key..":"..os.time())
+   end
+  end
+ end
+end)
+CreateLuaEvent(function()
+ for k,t in pairs(completedQuests) do if os.time()-t>300 then completedQuests[k]=nil end end
+ for k,t in pairs(helpedAt) do if os.time()-t>600 then helpedAt[k]=nil end end
+end,60000,0)
diff --git a/app/api/operations/route.ts b/app/api/operations/route.ts
new file mode 100644
index 0000000..cf71942
--- /dev/null
+++ b/app/api/operations/route.ts
@@ -0,0 +1,25 @@
+import {env} from 'cloudflare:workers';
+import {z} from 'zod';
+import {D1Store} from '@/core/store';
+import type {RuntimeConfig} from '@/core/types';
+const sample=z.object({host:z.enum(['ubuntu','windows']),at:z.number().finite(),cpuPercent:z.number().min(0).max(100),memoryTotalMB:z.number().nonnegative(),memoryAvailableMB:z.number().nonnegative(),diskFreeGB:z.number().nonnegative(),databaseMB:z.number().nonnegative().optional(),logsMB:z.number().nonnegative().optional(),modelAvailable:z.boolean().optional(),runtimeService:z.string().max(40).optional(),maintenance:z.string().max(500).optional()}).strict();
+async function ensure(){await env.DB!.prepare('CREATE TABLE IF NOT EXISTS operations_samples (host TEXT PRIMARY KEY,at INTEGER,payload TEXT)').run();}
+export async function GET(){
+ await ensure();const rows=await env.DB!.prepare('SELECT payload FROM operations_samples').all<{payload:string}>();
+ const s=await new D1Store().load(),now=Date.now()/1000;
+ const stuck=s.bots.filter(b=>b.status==='online'&&b.world&&now-b.world.at<120&&!b.world.inCombat&&b.world.stationarySince&&now-b.world.stationarySince>600&&['quest','explore'].includes(b.lastDecision?.action??'')).map(b=>({name:b.name,minutes:Math.floor((now-b.world!.stationarySince!)/60),zone:b.zone}));
+ return Response.json({samples:rows.results.map(r=>JSON.parse(r.payload)),stuck,retentionDays:s.opsRetentionDays??7,rosterAt:s.aleRosterAt??null},{headers:{'Cache-Control':'no-store'}});
+}
+export async function POST(request:Request){
+ const token=(env as unknown as RuntimeConfig).AUTONOMY_TOKEN;
+ if(!token||request.headers.get('authorization')!==`Bearer ${token}`)return Response.json({error:'Unauthorized'},{status:401});
+ try{
+  const raw=await request.text();if(raw.length>4000)throw new Error('Sample too large');const body=sample.parse(JSON.parse(raw));
+  if(Math.abs(Date.now()/1000-body.at)>180)throw new Error('Stale telemetry');
+  await ensure();await env.DB!.prepare('INSERT INTO operations_samples VALUES (?,?,?) ON CONFLICT(host) DO UPDATE SET at=excluded.at,payload=excluded.payload WHERE excluded.at>operations_samples.at').bind(body.host,body.at,JSON.stringify(body)).run();
+  // Only terminal commands are eligible; awaiting receipts and character state survive.
+  const s=await new D1Store().load();const before=new Date(Date.now()-(s.opsRetentionDays??7)*86400_000).toISOString();
+  if(body.host==='ubuntu')await env.DB!.prepare("DELETE FROM ale_commands WHERE status IN ('completed','failed') AND completed_at<? AND id NOT IN (SELECT command_id FROM community_actions WHERE status='pending') AND NOT EXISTS (SELECT 1 FROM conversation_requests c WHERE c.status='awaiting_delivery' AND instr(c.result,ale_commands.id)>0)").bind(before).run();
+  return Response.json({ok:true});
+ }catch(e){return Response.json({error:e instanceof Error?e.message:'Invalid telemetry'},{status:400});}
+}
diff --git a/app/community-panel.tsx b/app/community-panel.tsx
new file mode 100644
index 0000000..909f207
--- /dev/null
+++ b/app/community-panel.tsx
@@ -0,0 +1,23 @@
+'use client';
+import {useEffect,useState} from 'react';
+import type {State} from '@/core/types';
+import {Button} from '@/components/ui/button';
+export function CommunityPanel({state,act,busy}:{state:State;act:(a:any)=>Promise<any>;busy:boolean}){
+ const [filter,setFilter]=useState('all');const c=state.community;
+ const parties=Object.entries(state.bots.filter(b=>b.status==='online'&&b.world?.groupId).reduce<Record<string,State['bots']>>((groups,b)=>{(groups[b.world!.groupId]??=[]).push(b);return groups;},{}));
+ return <>
+  <section className="panel"><div className="panel-head"><h2>Cooperative play</h2></div><div className="panel-body"><p>Maximum 50 residents. Group and guild changes appear as confirmed only after the game accepts them.</p><div className="actions mt-5">
+   <Button disabled={busy} variant="outline" onClick={()=>act({type:'communityPolicy',partiesEnabled:!(c?.partiesEnabled??true),guildsEnabled:c?.guildsEnabled??true})}>Automatic parties: {c?.partiesEnabled===false?'off':'on'}</Button>
+   <Button disabled={busy} variant="outline" onClick={()=>act({type:'communityPolicy',partiesEnabled:c?.partiesEnabled??true,guildsEnabled:!(c?.guildsEnabled??true)})}>Guild recruitment: {c?.guildsEnabled===false?'off':'on'}</Button>
+  </div></div></section>
+  <div className="section-grid mt-5"><section className="panel"><div className="panel-head"><h2>Live parties</h2></div><div className="panel-body">{parties.length?parties.map(([id,bots])=><div className="memory" key={id}><strong>{bots?.map(b=>b.name).join(', ')}</strong><p>{bots?.[0]?.zone} · {bots?.length} observed members</p></div>):<p>No parties currently observed.</p>}</div></section>
+  <section className="panel"><div className="panel-head"><h2>Guild goals</h2></div><div className="panel-body">{c?.guilds.length?c.guilds.map(g=><div className="memory" key={g.id}><strong>{g.name}</strong><p>{g.progress} confirmed contributions · milestone {g.target}</p><label>Shared goal <select aria-label={`${g.name} goal`} value={g.goal} disabled={busy} onChange={e=>act({type:'guildGoal',guildId:g.id,goal:e.target.value})}><option value="quest">Complete quests together</option><option value="support">Help guildmates in combat</option><option value="explore">Explore other maps</option></select></label></div>):<p>Waiting for guild observations.</p>}</div></section></div>
+  <section className="panel mt-5"><div className="panel-head"><h2>Social activity</h2><select aria-label="Social activity filter" value={filter} onChange={e=>setFilter(e.target.value)}>{['all','conversation','relationship','invitation','party','leave','recruit','guild'].map(v=><option key={v}>{v}</option>)}</select></div><div className="panel-body">{[...(c?.feed??[])].reverse().filter(e=>filter==='all'||e.kind===filter).map(e=><article className="memory" key={e.id}><small>{new Date(e.at).toLocaleString()} · {e.kind} · {e.status??'observed'}</small><h3>{e.names.join(' ↔ ')}</h3><p style={{whiteSpace:'pre-wrap'}}>{e.text}</p>{e.affinityDelta!==undefined&&<small>Trust change: {e.affinityDelta>0?'+':''}{e.affinityDelta}</small>}</article>)}{!c?.feed.length&&<p>No confirmed social activity recorded yet.</p>}</div></section>
+ </>;
+}
+export function OperationsPanel({state,act,busy}:{state:State;act:(a:any)=>Promise<any>;busy:boolean}){
+ const [data,setData]=useState<any>(null),[error,setError]=useState('');
+ useEffect(()=>{let alive=true;const refresh=async()=>{try{const r=await fetch('/api/operations');if(!r.ok)throw new Error('Health data unavailable');const d=await r.json();if(alive){setData(d);setError('');}}catch(e){if(alive)setError(String(e));}};void refresh();const timer=setInterval(refresh,10000);return()=>{alive=false;clearInterval(timer);};},[]);
+ return <><div className="section-grid">{['ubuntu','windows'].map(host=>{const s=data?.samples.find((s:any)=>s.host===host),stale=!s||Date.now()/1000-s.at>180;return <section className="panel" key={host}><div className="panel-head"><h2>{host==='ubuntu'?'Ubuntu server':'Windows PC'}</h2></div><div className="panel-body">{s?<><p>{stale?'Telemetry stale — values may have changed':'Current telemetry'} · {new Date(s.at*1000).toLocaleTimeString()}</p>{[['CPU',s.cpuPercent.toFixed(1)+'%'],['Available RAM',Math.round(s.memoryAvailableMB)+' / '+Math.round(s.memoryTotalMB)+' MB'],['Free disk',s.diskFreeGB.toFixed(1)+' GB'],...(s.databaseMB!==undefined?[['Application database',s.databaseMB.toFixed(1)+' MB'],['Logs',s.logsMB.toFixed(1)+' MB'],['Model',s.modelAvailable?'Available':'Unavailable'],['Runtime recovery',s.runtimeService]]:[])].map(([label,value]:any)=><div className="health-row" key={label}><span>{label}</span><strong>{value}</strong></div>)}{s.memoryAvailableMB<1024&&<p className="notice">Memory pressure: keep the population capped at 50.</p>}<p className="fineprint">{s.maintenance}</p></>:<p>Waiting for telemetry from this machine.</p>}</div></section>;})}</div>
+ <section className="panel mt-5"><div className="panel-head"><h2>Storage and stalled activity</h2></div><div className="panel-body">{error&&<p role="alert">{error}</p>}<label>Keep application command history for <select aria-label="History retention" disabled={busy} value={state.opsRetentionDays??7} onChange={e=>act({type:'retentionPolicy',days:Number(e.target.value)})}>{[3,7,14,30].map(n=><option value={n} key={n}>{n} days</option>)}</select></label><p className="fineprint">Memories, relationships and memorials are preserved. Acknowledged game transport expires after one day; archived snapshots use the selected retention. Logs rotate at 10 MB with three archives. The social feed holds 250 entries.</p><h3>Possible stalled bots</h3><p className="fineprint">Stationary for over 10 minutes while intending to quest or explore. This is a review signal, not proof of being stuck; no automatic teleporting.</p>{data?.stuck?.length?data.stuck.map((b:any)=><p key={b.name}>{b.name} · {b.zone} · {b.minutes} minutes</p>):<p>No candidates detected.</p>}</div></section></>;
+}
diff --git a/app/page.tsx b/app/page.tsx
index b73b0d7..036810e 100644
--- a/app/page.tsx
+++ b/app/page.tsx
@@ -1,4 +1,5 @@
 'use client';
+import {CommunityPanel,OperationsPanel} from './community-panel';
 import { useState,useEffect,useCallback } from 'react';
 import { LayoutDashboard,Users,BookOpen,Compass,Server,Activity,Brain,Sparkles,Plus,Play,Pause,ArrowRight,Shield,Terminal,ScrollText,Radio,RefreshCw,Heart,MapPin,Network,Copy,Send,House,Globe2,Moon,Sun,Skull,Clock3 } from 'lucide-react';
 import { SidebarProvider,Sidebar,SidebarHeader,SidebarContent,SidebarMenu,SidebarMenuItem,SidebarMenuButton,SidebarFooter,SidebarTrigger } from '@/components/ui/sidebar';
@@ -16,7 +17,7 @@ import { Table,TableHeader,TableRow,TableHead,TableBody,TableCell } from '@/comp
 import { Skeleton } from '@/components/ui/skeleton';
 import { Toaster,toast } from 'sonner';
 import type { State,Bot,Recipe,RealmEvent,Activity as BotActivity } from '@/core/types';
-const NAV=[['Dashboard',LayoutDashboard],['World Monitor',Globe2],['Realm Director',Compass],['World & Housing',House],['Bots',Users],['Bot Recipes',BookOpen],['Memory & Bonds',Heart],['Event Stream',Activity],['GM Console',Terminal],['Server & Models',Server]] as const;
+const NAV=[['Dashboard',LayoutDashboard],['World Monitor',Globe2],['Social Life',Heart],['System Health',Activity],['Realm Director',Compass],['World & Housing',House],['Bots',Users],['Bot Recipes',BookOpen],['Memory & Bonds',Heart],['Event Stream',Activity],['GM Console',Terminal],['Server & Models',Server]] as const;
 const ACTIVITIES:BotActivity[]=['explore','quest','socialize','trade','rest'];
 function Choice({value,onChange,items,label}:{value:string;onChange:(v:string)=>void;items:{value:string;label:string}[];label:string}){return <Select value={value} onValueChange={onChange}><SelectTrigger aria-label={label}><SelectValue/></SelectTrigger><SelectContent>{items.map(i=><SelectItem key={i.value} value={i.value}>{i.label}</SelectItem>)}</SelectContent></Select>}
 const options=(items:string[])=>items.map(value=>({value,label:value}));
@@ -47,6 +48,8 @@ export default function Home(){
  {page==='Bot Recipes'&&<><div className="notice">Recipes are versioned. Saving a recipe preserves existing bots’ personalities until you explicitly apply the new version.</div><div className="recipe-grid">{state.recipes.map((r,i)=><button key={r.id} className="panel recipe-card" onClick={()=>{setRecipe(r);setRecipeOpen(true)}}><div style={{display:'flex',justifyContent:'space-between'}}><span className="recipe-symbol">{i%2?<Compass size={23}/>:<BookOpen size={23}/>}</span><small>VERSION {r.version}</small></div><h3>{r.name}</h3><p>{r.description}</p><div className="tags">{r.tags.map(t=><span className="tag" key={t}>{t}</span>)}</div><div style={{display:'flex',justifyContent:'space-between',marginTop:21}}><small>{state.bots.filter(b=>b.recipeId===r.id).length} bot identities</small><small style={{color:'#9abef7'}}>Edit recipe →</small></div></button>)}</div></>}
  {page==='Realm Director'&&<Director state={state} act={act} busy={busy}/>}
  {page==='Memory & Bonds'&&<div className="recipe-grid">{state.bots.map(b=><Panel key={b.id} title={b.name} icon={Heart} action={<Button variant="ghost" size="sm" onClick={()=>setBotId(b.id)}>Open profile</Button>}><div className="panel-body"><p className="list-muted">{b.memories.length} memories · {b.relationships.length} relationships</p><div className="memory"><p>{b.memories.at(-1)?.text??'No memories yet.'}</p></div>{b.relationships.map(r=><p className="list-muted" key={r.targetId}>{state.bots.find(x=>x.id===r.targetId)?.name} · {r.affinity>0?'+':''}{r.affinity} affinity<br/>{r.note}</p>)}</div></Panel>)}</div>}
+ {page==='Social Life'&&<CommunityPanel state={state} act={act} busy={busy}/>}
+ {page==='System Health'&&<OperationsPanel state={state} act={act} busy={busy}/>}
  {page==='Event Stream'&&<EventStream state={state}/>}
  {page==='Server & Models'&&<Settings state={state} act={act} busy={busy} capabilities={capabilities}/>}
  {page==='GM Console'&&<GM state={state} act={act} busy={busy} capabilities={capabilities} setConfirm={setConfirm}/>}
diff --git a/core/autonomy.ts b/core/autonomy.ts
index 96bfa38..1f5350b 100644
--- a/core/autonomy.ts
+++ b/core/autonomy.ts
@@ -141,6 +141,8 @@ export async function runLiveAutonomyTick(
 
  let bot=pick.bot;
  const observation=observationFrom(bot,pick.obs,events);
+ const guild=s.community?.guilds.find(g=>g.id===bot.world?.guildId);
+ if(guild)observation.summary+=` Your guild ${guild.name} works toward ${guild.goal}; confirmed progress ${guild.progress}/${guild.target}. Favor helpful actions toward that goal when safe.`;
  const brain=providerForBot(bot,s.settings,config);
  let decision:Decision;
  let usedFallback=false;
diff --git a/core/community.ts b/core/community.ts
new file mode 100644
index 0000000..149d592
--- /dev/null
+++ b/core/community.ts
@@ -0,0 +1,118 @@
+import type {Bot,State,StateStore,SocialEntry} from './types';
+import {luaString} from './ale';
+import {queueAleCommand} from './ale-store';
+
+export function community(s:State){return s.community??(s.community={feed:[],evidence:[],guilds:[],partiesEnabled:true,guildsEnabled:true});}
+export function socialEntry(s:State,e:SocialEntry){const c=community(s);if(!c.feed.some(x=>x.id===e.id))c.feed.push(e);c.feed=c.feed.slice(-250);}
+export function bondEvidence(s:State,id:string,a:Bot,b:Bot,reason:string,delta:number){
+ const c=community(s);if(c.evidence.includes(id)||a.id===b.id)return false;
+ c.evidence.push(id);c.evidence=c.evidence.slice(-1000);
+ for(const [from,to] of [[a,b],[b,a]]){
+  let r=from.relationships.find(x=>x.targetId===to.id);
+  if(!r){r={targetId:to.id,affinity:0,note:reason};from.relationships.push(r);}
+  r.affinity=Math.max(-100,Math.min(100,r.affinity+delta));r.note=reason;
+  from.relationships=from.relationships.slice(-100);
+ }
+ socialEntry(s,{id,at:new Date().toISOString(),kind:'relationship',names:[a.name,b.name],text:reason,affinityDelta:delta,status:'confirmed'});
+ return true;
+}
+export async function changeCommunity(store:StateStore,fn:(s:State)=>void){
+ for(let n=0;n<4;n++){const s=await store.load(),r=s.revision;fn(s);try{await store.save(s,r);return;}catch(e){if(n===3||!(e instanceof Error)||!e.message.includes('State changed'))throw e;}}
+}
+export function observePresence(s:State,b:Bot,p:Record<string,unknown>){
+ const at=Number(p.observedAt);if(!Number.isFinite(at)||at<=(b.world?.at??0)||Math.abs(Date.now()/1000-at)>120)return;
+ if(typeof p.team!=='number'||typeof p.x!=='number'||typeof p.y!=='number')return;
+ const old=b.world;
+ const stationary=old&&old.mapId===p.mapId&&Math.hypot(old.x-p.x,old.y-p.y)<3;
+ b.world={at,team:p.team,guildId:Number(p.guildId)||0,guildName:String(p.guildName||''),guildRank:Number(p.guildRank)||0,groupId:String(p.groupId||''),groupNames:String(p.groupNames||'').split(',').filter(Boolean),nearby:String(p.nearbyBots||'').split(',').filter(Boolean),inCombat:p.inCombat===true,x:p.x,y:p.y,mapId:Number(p.mapId)||0,stationarySince:stationary?(old.stationarySince??old.at):at};
+ const c=community(s);
+ if(b.world.guildId&&!c.guilds.some(g=>g.id===b.world!.guildId))c.guilds.push({id:b.world.guildId,name:b.world.guildName,goal:['quest','support','explore'][b.world.guildId%3] as 'quest'|'support'|'explore',progress:0,target:20});
+ if(old&&old.mapId!==b.world.mapId&&b.world.guildId){
+  const g=c.guilds.find(g=>g.id===b.world!.guildId),key=`explore:${b.id}:${b.world.mapId}:${Math.floor(at/86400)}`;
+  if(g?.goal==='explore'&&!c.evidence.includes(key)){g.progress++;c.evidence.push(key);c.evidence=c.evidence.slice(-1000);socialEntry(s,{id:key,at:new Date().toISOString(),kind:'guild',names:[b.name,g.name],text:'Reached another map for the guild exploration goal.',status:'confirmed'});}
+ }
+
+}
+export function applyCooperation(s:State,p:Record<string,unknown>){
+ const at=Number(p.observedAt);if(!Number.isFinite(at)||Math.abs(Date.now()/1000-at)>120)return;
+ const id=String(p.evidenceId||'');if(!id||community(s).evidence.includes(id))return;
+ const a=s.bots.find(b=>b.autonomy?.characterGuid===p.characterGuid),b=s.bots.find(b=>b.autonomy?.characterGuid===p.peerGuid);
+ if(!a||!b||a.status==='dead'||b.status==='dead')return;
+ const kind=p.cooperation;
+ if(kind!=='quest'&&kind!=='assist')return;
+ if(bondEvidence(s,id,a,b,kind==='quest'?'Completed the same quest while adventuring together.':'Helped defeat an enemy together.',kind==='quest'?3:1)){
+  for(const bot of [a,b]){bot.memories.push({id,text:kind==='quest'?`Completed quest ${String(p.questId)} with ${bot.id===a.id?b.name:a.name}.`:`Fought alongside ${bot.id===a.id?b.name:a.name}.`,importance:6,source:'observation',at:new Date().toISOString()});bot.memories=bot.memories.slice(-100);}
+  if(a.world?.guildId&&a.world.guildId===b.world?.guildId){const g=community(s).guilds.find(g=>g.id===a.world!.guildId);if(g&&((g.goal==='quest'&&kind==='quest')||(g.goal==='support'&&kind==='assist')))g.progress++;}
+ }
+}
+const affinity=(a:Bot,b:Bot)=>a.relationships.find(r=>r.targetId===b.id)?.affinity??0;
+const fresh=(b:Bot)=>b.status==='online'&&b.autonomy?.managed&&b.world&&Date.now()/1000-b.world.at<90&&!b.world.inCombat;
+export function partyDecision(a:Bot,b:Bot){
+ if(!fresh(a)||!fresh(b)||a.id===b.id||a.world!.team!==b.world!.team||Math.abs(a.level-b.level)>10||!a.world!.nearby.includes(b.name)||!b.world!.nearby.includes(a.name))return {accepted:false,reason:'No compatible nearby pair'};
+ const willing=(x:Bot,y:Bot)=>affinity(x,y)>=0&&(x.personality.sociability>=35||affinity(x,y)>=5)&&x.personality.activities.some(v=>v==='quest'||v==='explore');
+ return {accepted:willing(a,b)&&willing(b,a),reason:willing(a,b)&&willing(b,a)?'Both accepted: compatible levels, shared adventure interests, and no hostile bond.':'One character prefers to adventure alone or does not trust the other.'};
+}
+export function compileCommunityAction(kind:'party'|'leave'|'recruit',a:Bot,b?:Bot){
+ const lines=[`local a=GetPlayerByName(${luaString(a.name)})`,`if not a or a:GetGUIDLow()~=${a.autonomy!.characterGuid} or not a:IsPlayerbot() or a:IsDead() or a:IsInCombat() then error('Resident unavailable') end`];
+ if(kind==='leave'){
+  lines.push(`local g=a:GetGroup();if not g then return 'Already solo' end`,`if tostring(g:GetGUID())~=${luaString(a.world!.groupId)} then error('Party changed') end`,`if #g:GetMembers()~=g:GetMembersCount() then error('Party has offline members') end;for _,m in pairs(g:GetMembers()) do if not m:IsPlayerbot() then error('Human party is protected') end end`,`a:RemoveFromGroup()`,`if a:GetGroup() then error('Departure was not applied') end`);
+ }else{
+  if(!b)throw new Error('Peer required');
+  lines.push(`local b=GetPlayerByName(${luaString(b.name)})`,`if not b or b:GetGUIDLow()~=${b.autonomy!.characterGuid} or not b:IsPlayerbot() or b:IsDead() or b:IsInCombat() or a:GetTeam()~=b:GetTeam() or a:GetMapId()~=b:GetMapId() or a:GetPhaseMask()~=b:GetPhaseMask() or a:GetDistance(b)>35 then error('Peer unavailable nearby') end`);
+  if(kind==='party')lines.push(`if math.abs(a:GetLevel()-b:GetLevel())>10 then error('Level mismatch') end`,`local g=a:GetGroup();if g and b:GetGroup()==g then return 'Already grouped' end`,`if b:GetGroup() then error('Peer already grouped') end`,`if g then if g:IsRaidGroup() or g:GetMembersCount()>=5 then error('Party full') end;if #g:GetMembers()~=g:GetMembersCount() then error('Party has offline members') end;for _,m in pairs(g:GetMembers()) do if not m:IsPlayerbot() then error('Human party is protected') end end;if not g:AddMember(b) then error('Party join failed') end else g=a:GroupCreate(b) end`,`if not g or b:GetGroup()~=g then error('Party membership was not applied') end`);
+  else lines.push(`local g=a:GetGuild();if not g or a:GetGuildId()~=${a.world!.guildId} or a:GetGuildRank()~=0 then error('Guild leader unavailable') end`,`if b:GetGuildId()==a:GetGuildId() then return 'Already a member' end`,`if b:GetGuildId()~=0 then error('Already belongs to a guild') end`,`g:AddMember(b)`,`if b:GetGuildId()~=a:GetGuildId() then error('Guild admission failed') end`);
+ }
+ lines.push('AzerothAIEmitSnapshots()','return "Confirmed '+kind+'"');return lines.join('; ');
+}
+async function ensure(db:D1Database){
+ await db.prepare('CREATE TABLE IF NOT EXISTS community_actions (id TEXT PRIMARY KEY,created_at TEXT,kind TEXT,a TEXT,b TEXT,command_id TEXT,status TEXT,reason TEXT)').run();
+ await db.prepare('CREATE TABLE IF NOT EXISTS community_clock (id TEXT PRIMARY KEY,at INTEGER)').run();
+}
+export async function communityTick(store:StateStore,db:D1Database){
+ await ensure(db);
+ const pending=await db.prepare("SELECT * FROM community_actions WHERE status='pending' LIMIT 20").all<any>();
+ for(const action of pending.results){
+  const receipt=await db.prepare('SELECT status,error FROM ale_commands WHERE id=?').bind(action.command_id).first<any>();
+  if(!receipt||!['completed','failed'].includes(receipt.status))continue;
+  await changeCommunity(store,s=>{
+   const a=s.bots.find(b=>b.id===action.a),b=s.bots.find(b=>b.id===action.b);if(!a)return;
+   const proposal=community(s).feed.find(e=>e.id===action.id+':proposal');if(proposal){proposal.status=receipt.status==='completed'?'confirmed':'failed';proposal.text=action.reason;}
+   socialEntry(s,{id:action.id,at:new Date().toISOString(),kind:action.kind,names:[a.name,...(b?[b.name]:[])],text:receipt.status==='completed'?action.reason:String(receipt.error||'Game rejected action').replace(/^.*:\d+:\s*/,''),status:receipt.status==='completed'?'confirmed':'failed'});
+   if(receipt.status==='completed'&&b&&action.kind==='party'&&bondEvidence(s,action.id+':bond',a,b,'Accepted an invitation to adventure together.',1)){
+    for(const [from,to] of [[a,b],[b,a]]){from.memories.push({id:action.id,text:'Joined a party with '+to.name+' to adventure together.',importance:6,source:'observation',at:new Date().toISOString()});from.memories=from.memories.slice(-100);}
+   }
+  });
+  await db.prepare('UPDATE community_actions SET status=? WHERE id=?').bind(receipt.status,action.id).run();
+ }
+ const now=Date.now();
+ await db.prepare("INSERT OR IGNORE INTO community_clock VALUES ('tick',0)").run();
+ const gate=await db.prepare("UPDATE community_clock SET at=? WHERE id='tick' AND at<?").bind(now,now-30_000).run();if(gate.meta.changes!==1)return;
+ await db.prepare("DELETE FROM community_actions WHERE status!='pending' AND created_at<?").bind(new Date(now-7*86400_000).toISOString()).run();
+ const s=await store.load(),c=community(s),bots=s.bots.filter(b=>fresh(b));
+ const recent=await db.prepare('SELECT a,b FROM community_actions WHERE created_at>?').bind(new Date(now-10*60_000).toISOString()).all<any>();
+ const busy=new Set(recent.results.flatMap(r=>[r.a,r.b]));
+ for(const a of bots){
+  if(busy.has(a.id))continue;
+  // Leave only a bot-only party whose peers have moved away, never a human party.
+  const far=a.world!.groupId&&a.world!.groupNames.length>1&&a.world!.groupNames.filter(n=>n!==a.name).every(n=>!a.world!.nearby.includes(n));
+  if(c.partiesEnabled&&far){
+   await db.prepare('INSERT OR IGNORE INTO community_clock VALUES (?,?)').bind('apart:'+a.id,now).run();
+   const apart=await db.prepare('SELECT at FROM community_clock WHERE id=?').bind('apart:'+a.id).first<{at:number}>();
+   if(apart&&now-apart.at>10*60_000){await propose('leave',a,undefined,'Left the party after ten minutes apart.');return;}
+  }else await db.prepare('DELETE FROM community_clock WHERE id=?').bind('apart:'+a.id).run();
+  for(const b of bots){
+   if(busy.has(b.id)||a.id===b.id||!a.world!.nearby.includes(b.name))continue;
+   if(c.guildsEnabled&&a.world!.guildId&&a.world!.guildRank===0&&!b.world!.guildId&&affinity(a,b)>=3&&affinity(b,a)>=3&&partyDecision(a,b).accepted){await propose('recruit',a,b,`Accepted an invitation to ${a.world!.guildName} after building mutual trust.`);return;}
+   if(c.partiesEnabled&&!b.world!.groupId&&(!a.world!.groupId||a.world!.groupNames.length<5)){
+    const decision=partyDecision(a,b);
+    if(!decision.accepted){if(decision.reason==='No compatible nearby pair')continue;await db.prepare('INSERT INTO community_actions VALUES (?,?,?,?,?,?,?,?)').bind(crypto.randomUUID(),new Date().toISOString(),'declined',a.id,b.id,'','declined',decision.reason).run();await changeCommunity(store,s=>socialEntry(s,{id:crypto.randomUUID(),at:new Date().toISOString(),kind:'invitation',names:[a.name,b.name],text:decision.reason,status:'declined'}));return;}
+    await propose('party',a,b,decision.reason);return;
+   }
+  }
+ }
+ async function propose(kind:'party'|'leave'|'recruit',a:Bot,b:Bot|undefined,reason:string){
+  const command=await queueAleCommand(db,compileCommunityAction(kind,a,b));
+  await db.prepare('INSERT INTO community_actions VALUES (?,?,?,?,?,?,?,?)').bind(command.id,new Date().toISOString(),kind,a.id,b?.id??'',command.id,'pending',reason).run();
+  await changeCommunity(store,s=>socialEntry(s,{id:command.id+':proposal',at:new Date().toISOString(),kind:'invitation',names:[a.name,...(b?[b.name]:[])],text:reason+' Awaiting game confirmation.',status:'pending'}));
+ }
+}
diff --git a/core/conversation.ts b/core/conversation.ts
index 5539772..25339a1 100644
--- a/core/conversation.ts
+++ b/core/conversation.ts
@@ -1,3 +1,4 @@
+import {bondEvidence,socialEntry,communityTick} from './community';
 import { z } from 'zod';
 import { queueAleCommand } from './ale-store';
 import { luaString } from './ale';
@@ -145,14 +146,10 @@ async function remember(store:StateStore,botId:string,request:ConversationReques
    if(peer){
     peer.memories.push({id:request.id,text:`I said to ${bot.name}: "${request.message.slice(0,180)}" They replied: "${reply.slice(0,180)}"`,importance:6,source:'observation',at:new Date().toISOString()});
     peer.memories=peer.memories.slice(-100);
-    for(const [from,to] of [[bot,peer],[peer,bot]]){
-     const existing=from.relationships.find(r=>r.targetId===to.id);
-     if(existing)existing.note='We have spoken together in person.';
-     else from.relationships.push({targetId:to.id,affinity:0,note:'We have spoken together in person.'});
-     from.relationships=from.relationships.slice(-100);
-    }
+    bondEvidence(state,request.id+':bond',bot,peer,'Shared a confirmed conversation.',1);
    }
   }
+  socialEntry(state,{id:request.id,at:new Date().toISOString(),kind:'conversation',names:[request.speakerName,bot.name],text:`${request.speakerName}: ${request.message}\n${bot.name}: ${reply}`,status:'confirmed'});
   bot.simulationBand='foreground';
   realmEvent(state,'memory',`${bot.name} had a live conversation with ${request.speakerName}.`,bot.id);
   try{
@@ -177,6 +174,7 @@ export async function runConversationTick(store:StateStore,db:D1Database,config:
   }
  }
  await cleanupConversations(db);
+ await communityTick(store,db);
  const request=await leaseConversation(db);
  if(!request)return {ok:true,ran:false,reason:'No player conversation waiting'};
 
diff --git a/core/service.ts b/core/service.ts
index b3308fb..cb4a017 100644
--- a/core/service.ts
+++ b/core/service.ts
@@ -1,3 +1,4 @@
+import {community,observePresence,applyCooperation,socialEntry} from './community';
 import { runGM } from './gm';
 import { actionSchema } from './validation';
 import { connectors } from './connectors';
@@ -72,6 +73,7 @@ function observedHardcoreDeath(s:State,b:Bot,observation:Observation){
 export async function applyAuthoritativeAleEvent(store:StateStore,kind:string,payload:Record<string,unknown>){
  let s=await store.load();
  const revision=s.revision;
+ if(kind==='player.snapshot'&&payload.cooperation){applyCooperation(s,payload);await store.save(s,revision);return {matched:true,cooperation:true};}
  // Complete world snapshots own presence once available; historical events
  // must never bring disconnected residents back online.
  if(kind==='player.snapshot' && payload.roster===true){
@@ -151,6 +153,7 @@ export async function applyAuthoritativeAleEvent(store:StateStore,kind:string,pa
  }
  if(b.status==='retired')return {matched:true,botId:b.id,retired:true};
 
+ if(kind==='player.snapshot')observePresence(s,b,payload);
  b.level=level;
  if(zone)b.zone=zone;
 
@@ -231,6 +234,13 @@ export async function execute(store:StateStore,input:unknown,config:RuntimeConfi
  if(a.type==='gm'){
   const id=crypto.randomUUID();s.operations[id]={started:Date.now(),botId:'gm'};event(s,'gm',`${a.live?'LIVE':'SIMULATED'} command requested: ${a.command}`);await store.save(s,revision);
   try{const result=await runGM(a.command,a.live,a.confirmed,config);delete s.operations[id];event(s,'gm',`${a.live?'LIVE':'SIMULATED'} ${result.command}: ${result.output}`);await store.save(s,s.revision);return result;}catch(e){delete s.operations[id];event(s,'error',`GM command failed: ${e instanceof Error?e.message:'Unknown error'}`);await store.save(s,s.revision);throw e;}
+ }else if(a.type==='retentionPolicy'){
+  s.opsRetentionDays=a.days;
+ }else if(a.type==='communityPolicy'){
+  Object.assign(community(s),{partiesEnabled:a.partiesEnabled,guildsEnabled:a.guildsEnabled});
+ }else if(a.type==='guildGoal'){
+  const g=community(s).guilds.find(g=>g.id===a.guildId);if(!g)throw new Error('Guild not observed');g.goal=a.goal;g.progress=0;
+  socialEntry(s,{id:crypto.randomUUID(),at:new Date().toISOString(),kind:'guild',names:[g.name],text:'Guild goal changed to '+a.goal,status:'confirmed'});
  }else if(a.type==='director'){
   s.director={experience:a.experience,zone:a.zone,playerName:a.playerName,brief:a.brief};
   for(const b of s.bots.filter(b=>b.status!=='retired'&&b.status!=='dead')) b.goal=`${a.experience} in ${a.zone}${a.playerName?' around '+a.playerName:''}: ${a.brief}`.slice(0,200);
diff --git a/core/types.ts b/core/types.ts
index d247abb..76a07cd 100644
--- a/core/types.ts
+++ b/core/types.ts
@@ -10,7 +10,11 @@ export type DeathRecord = {id:string; at:string; zone:string; level:number; caus
 export type Home = {id:string; name:string; zone:string; type:HousingType; capacity:number; ownerIds:string[]; residentIds:string[]; storageSlots:number; safety:number; description:string};
 export type Routine = {wakeHour:number; sleepHour:number; preferredZones:string[]};
 export type AutonomyState = {managed:boolean; characterGuid?:number; accountId?:number; observedAt?:string; lastIntentAt?:string; nextIntentAt?:string; lastAleCommandId?:string};
-export type Bot = {id:string; name:string; role:string; race:string; level:number; zone:string; status:Status; tier:AgentTier; mortal:boolean; plotArmorHpFloor:number; simulationBand:SimulationBand; homeId?:string; routine:Routine; autonomy?:AutonomyState; recipeId:string; recipeVersion:number; personality:Recipe; goal:string; memories:Memory[]; relationships:Relationship[]; decisions:number; death?:DeathRecord; lastDecision?:Decision};
+export type WorldPresence = {at:number;team:number;guildId:number;guildName:string;guildRank:number;groupId:string;groupNames:string[];nearby:string[];inCombat:boolean;x:number;y:number;mapId:number;stationarySince?:number};
+export type SocialEntry = {id:string;at:string;kind:string;names:string[];text:string;affinityDelta?:number;status?:string};
+export type GuildGoal = {id:number;name:string;goal:'quest'|'support'|'explore';progress:number;target:number};
+export type Community = {feed:SocialEntry[];evidence:string[];guilds:GuildGoal[];partiesEnabled:boolean;guildsEnabled:boolean};
+export type Bot = {world?:WorldPresence;id:string; name:string; role:string; race:string; level:number; zone:string; status:Status; tier:AgentTier; mortal:boolean; plotArmorHpFloor:number; simulationBand:SimulationBand; homeId?:string; routine:Routine; autonomy?:AutonomyState; recipeId:string; recipeVersion:number; personality:Recipe; goal:string; memories:Memory[]; relationships:Relationship[]; decisions:number; death?:DeathRecord; lastDecision?:Decision};
 export type Decision = {action:Activity; reason:string; goal:string};
 export type RealmEvent = {id:string; seq:number; at:string; kind:'system'|'lifecycle'|'decision'|'memory'|'relationship'|'recipe'|'gm'|'death'|'housing'|'population'|'error'; message:string; botId?:string; mode:'simulation'|'azerothcore'};
 export type HardcoreSettings = {enabled:boolean; requireVerifiedDeath:boolean; memorialize:boolean};
@@ -18,7 +22,7 @@ export type PopulationSettings = {defaultZoneTarget:number; zoneMax:number; serv
 export type BrainRouterSettings = {enabled:boolean; residentModel:string; heroModel:string; backgroundUseLLM:boolean; residentMemoryLimit:number; heroMemoryLimit:number; residentMaxTokens:number; heroMaxTokens:number};
 export type WorldTrigger = {id:string; kind:'zone-change'|'interaction'|'time'|'manual'; zone:string; at:string; playerName?:string; detail?:string};
 export type PopulationPlan = {id:string; trigger:WorldTrigger; target:number; activeBefore:number; requested:number; capacity:number; selectedBotIds:string[]; rejectedReasons:string[]; createdAt:string};
-export type State = {revision:number; aleRosterAt?:number; bots:Bot[]; homes:Home[]; recipes:Recipe[]; events:RealmEvent[]; sequence:number; settings:{connector:'simulation'|'azerothcore'; provider:'deterministic'|'ollama'|'openai-compatible'; model:string; brains:BrainRouterSettings; hardcore:HardcoreSettings; population:PopulationSettings}; director:{experience:string; zone:string; playerName:string; brief:string}; population:{lastPlan?:PopulationPlan}; operations:Record<string,{started:number; botId:string}>};
+export type State = {revision:number; aleRosterAt?:number; community?:Community; opsRetentionDays?:number; bots:Bot[]; homes:Home[]; recipes:Recipe[]; events:RealmEvent[]; sequence:number; settings:{connector:'simulation'|'azerothcore'; provider:'deterministic'|'ollama'|'openai-compatible'; model:string; brains:BrainRouterSettings; hardcore:HardcoreSettings; population:PopulationSettings}; director:{experience:string; zone:string; playerName:string; brief:string}; population:{lastPlan?:PopulationPlan}; operations:Record<string,{started:number; botId:string}>};
 export type DeathSignal = {id:string; at:string; cause:string; killer?:string; zone?:string; verified:boolean};
 export type Observation = {zone:string; level:number; availableActions:Activity[]; summary:string; alive:boolean; death?:DeathSignal};
 export interface GameConnector {id:string; health():Promise<{ok:boolean; detail:string}>; observe(bot:Bot):Promise<Observation>; lifecycle(bot:Bot,action:'spawn'|'pause'|'resume'|'despawn'|'retire',requestId:string):Promise<void>; decide(bot:Bot,decision:Decision,requestId:string):Promise<{summary:string;zone?:string}>;}
diff --git a/core/validation.ts b/core/validation.ts
index 1189aad..b068abf 100644
--- a/core/validation.ts
+++ b/core/validation.ts
@@ -5,6 +5,9 @@ export const recipeSchema=z.object({id:z.string().max(80).optional(),name:z.stri
 const populationSchema=z.object({defaultZoneTarget:z.number().int().min(0).max(100),zoneMax:z.number().int().min(1).max(200),serverMax:z.number().int().min(1).max(1000),foregroundMax:z.number().int().min(1).max(200),backgroundMax:z.number().int().min(1).max(1000)});
 const brainsSchema=z.object({enabled:z.boolean(),residentModel:z.string().trim().min(1).max(100),heroModel:z.string().trim().min(1).max(100),backgroundUseLLM:z.boolean(),residentMemoryLimit:z.number().int().min(1).max(50),heroMemoryLimit:z.number().int().min(1).max(100),residentMaxTokens:z.number().int().min(64).max(2048),heroMaxTokens:z.number().int().min(64).max(4096)});
 export const actionSchema=z.discriminatedUnion('type',[
+ z.object({type:z.literal('retentionPolicy'),days:z.number().int().min(3).max(30)}),
+ z.object({type:z.literal('communityPolicy'),partiesEnabled:z.boolean(),guildsEnabled:z.boolean()}),
+ z.object({type:z.literal('guildGoal'),guildId:z.number().int().positive(),goal:z.enum(['quest','support','explore'])}),
  z.object({type:z.literal('createBot'),name:z.string().trim().regex(/^[A-Za-z][A-Za-z '-]{1,23}$/),role:z.enum(['Warrior','Priest','Mage','Rogue','Hunter','Paladin','Warlock','Druid','Shaman']),race:z.enum(['Human','Night Elf','Dwarf','Orc','Undead','Tauren','Gnome','Troll','Blood Elf','Draenei']),recipeId:z.string(),goal:z.string().trim().min(1).max(200)}),
  z.object({type:z.literal('lifecycle'),botId:z.string(),action:z.enum(['spawn','pause','resume','despawn','retire'])}),
  z.object({type:z.literal('think'),botId:z.string()}),
diff --git a/deploy/playable/install-user-recovery.py b/deploy/playable/install-user-recovery.py
new file mode 100644
index 0000000..6e4ef4d
--- /dev/null
+++ b/deploy/playable/install-user-recovery.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""Install current-user runtime recovery and telemetry. Enable lingering for boot startup."""
+from pathlib import Path
+import shutil,subprocess
+repo=Path(__file__).resolve().parents[2]
+units=Path.home()/'.config/systemd/user';units.mkdir(parents=True,exist_ok=True)
+node=shutil.which('node');python=shutil.which('python3');assert node and python
+(units/'azerothai-runtime.service').write_text(f'''[Unit]
+Description=AzerothAI web runtime
+After=network-online.target
+[Service]
+WorkingDirectory={repo}
+ExecStart={node} {repo}/scripts/start-local-runtime.mjs --lan
+Restart=always
+RestartSec=5
+StandardOutput=journal
+StandardError=journal
+[Install]
+WantedBy=default.target
+''')
+(units/'azerothai-operations.service').write_text(f'''[Unit]
+Description=AzerothAI telemetry and transport retention
+After=azerothai-runtime.service
+[Service]
+Type=oneshot
+WorkingDirectory={repo}
+ExecStart=/usr/bin/sg docker -c "{python} {repo}/scripts/operations-agent.py"
+TimeoutStartSec=50
+''')
+(units/'azerothai-operations.timer').write_text('''[Unit]
+Description=AzerothAI one-minute health sampling
+[Timer]
+OnBootSec=90
+OnUnitActiveSec=60
+[Install]
+WantedBy=timers.target
+''')
+subprocess.run(['systemctl','--user','daemon-reload'],check=True)
+# Runtime is enabled but started separately after handing over its existing process.
+subprocess.run(['systemctl','--user','enable','azerothai-runtime.service','azerothai-operations.timer'],check=True)
+subprocess.run(['systemctl','--user','start','azerothai-operations.timer'],check=True)
+print('User services installed. Start the runtime after stopping its previous unmanaged process.')
diff --git a/deploy/playable/windows-recovery.ps1 b/deploy/playable/windows-recovery.ps1
new file mode 100644
index 0000000..16f4a68
--- /dev/null
+++ b/deploy/playable/windows-recovery.ps1
@@ -0,0 +1,32 @@
+# Run as Richard at logon; no administrator password or API tokens are stored here.
+$ErrorActionPreference = 'Continue'
+$mutex = New-Object System.Threading.Mutex($false, 'Local\AzerothAIRecovery')
+if (-not $mutex.WaitOne(0)) { exit }
+$ssh = 'C:\Users\richard\Tools\MinGit\usr\bin\ssh.exe'
+$key = 'C:\Users\richard\.ssh\id_ed25519_azerothai'
+$ollama = 'C:\Users\richard\Tools\Ollama\ollama.exe'
+$logRoot = 'C:\Users\richard\Tools\AzerothAI'
+New-Item -ItemType Directory -Force $logRoot | Out-Null
+while ($true) {
+ try {
+  try { Invoke-RestMethod http://127.0.0.1:11434/api/tags -TimeoutSec 3 | Out-Null }
+  catch {
+   if (-not (Get-Process ollama -ErrorAction SilentlyContinue)) {
+    Start-Process $ollama -ArgumentList 'serve' -WindowStyle Hidden
+   }
+  }
+  $tunnel = Get-CimInstance Win32_Process -Filter "Name='ssh.exe'" | Where-Object { $_.CommandLine -like '*127.0.0.1:11434:127.0.0.1:11434*' }
+  if (-not $tunnel) {
+   Start-Process $ssh -ArgumentList @('-N','-o','BatchMode=yes','-o','StrictHostKeyChecking=yes','-o','ExitOnForwardFailure=yes','-o','ServerAliveInterval=15','-o','ServerAliveCountMax=3','-i',$key,'-R','127.0.0.1:11434:127.0.0.1:11434','endami@192.168.62.129') -WindowStyle Hidden
+  }
+  $os = Get-CimInstance Win32_OperatingSystem
+  $cpu = (Get-CimInstance Win32_Processor | Measure-Object LoadPercentage -Average).Average
+  $disk = Get-CimInstance Win32_LogicalDisk -Filter "DeviceID='C:'"
+  $sample = @{host='windows';at=[DateTimeOffset]::UtcNow.ToUnixTimeSeconds();cpuPercent=[double]$cpu;memoryTotalMB=$os.TotalVisibleMemorySize/1024;memoryAvailableMB=$os.FreePhysicalMemory/1024;diskFreeGB=$disk.FreeSpace/1GB;maintenance='Model and SSH tunnel recovery active at Windows logon'} | ConvertTo-Json -Compress
+  $encoded = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($sample))
+  & $ssh -o BatchMode=yes -o ConnectTimeout=8 -o StrictHostKeyChecking=yes -i $key endami@192.168.62.129 "python3 /home/endami/AzerothAI/scripts/operations-agent.py --windows $encoded" 2>&1 | Out-File -Append "$logRoot\recovery.log"
+ } catch { $_.Exception.Message | Out-File -Append "$logRoot\recovery.log" }
+ $log = Get-Item "$logRoot\recovery.log" -ErrorAction SilentlyContinue
+ if ($log -and $log.Length -gt 1MB) { Move-Item -Force $log.FullName "$logRoot\recovery.previous.log" }
+ Start-Sleep -Seconds 60
+}
diff --git a/docs/community-and-operations.md b/docs/community-and-operations.md
new file mode 100644
index 0000000..1bc5b3a
--- /dev/null
+++ b/docs/community-and-operations.md
@@ -0,0 +1,59 @@
+# Community and operations
+
+## Live social behavior
+
+The Social Life page shows the last 250 confirmed conversations, relationship
+changes, invitations, departures, and guild actions. Pending requests and failed
+native receipts are distinct from completed activity.
+
+A scheduler checks fresh (under 90 seconds) world observations every 30 seconds.
+Party partners must be nearby, same faction, within ten levels, and interested
+in questing/exploring. Both characters decide using sociability and their directed
+trust scores. Negative trust rejects the invitation. Guild recruitment requires
+mutual trust of at least 3, an online bot guild leader, and a guildless candidate.
+Characters never abandon an existing guild merely to fill a recruitment target.
+Each participant gets ten minutes between proposals. Bot-only parties remain at
+five members or fewer; native commands refuse to modify human parties or raids.
+A resident may depart after ten minutes apart from all party companions.
+
+Native receipts verify membership. Accepted parties grant +1 reciprocal trust.
+Confirmed conversations grant +1, shared completed quests +3, and helping attack
+the same enemy +1 (combat help is throttled per pair to five minutes). Trust is
+bounded to -100..100. Replayed evidence cannot grant repeated credit within the
+bounded evidence window. Memories and relationship lists retain at most 100 rows
+per resident; dead/retired identities are not candidates for new activities.
+
+Observed guilds receive an editable shared goal: quest together, support allies,
+or explore other maps. The guild goal enters high-level decision context.
+Progress uses observed cooperative quests, shared combat, or map changes (once
+per member/map/day). Guild creation and forced cross-guild transfers are excluded.
+
+## Health, retention and recovery
+
+System Health displays Ubuntu and Windows samples with explicit stale markers,
+CPU, available memory, free disk, application database/log sizes, and model health.
+Possible stalled bots are those stationary for ten minutes while intending to
+quest/explore, with fresh noncombat observations. No automatic teleport is used.
+
+The operations agent prunes acknowledged game transport at one day, as the relay
+already does. Archived snapshots and terminal application commands use the chosen
+3–30 day retention (default 7). Pending work, memories, guild goals, relationship
+state and memorials are preserved. Current application log files rotate at 10 MB
+with three copies. Database files may retain freed SQLite pages for reuse.
+
+Install `deploy/playable/install-user-recovery.py` as the realm owner. It registers
+`azerothai-runtime.service` with Restart=always and a minute operations timer in
+the user's systemd manager. Enable user lingering for reboot startup. Telemetry
+uses the realm owner's existing docker group, including in older user sessions.
+Existing system relay/autonomy services remain owned by the system manager.
+
+`deploy/playable/windows-recovery.ps1` checks the local model and SSH tunnel every
+minute and sends Windows readings through SSH (no API token stored on Windows).
+The scheduled task runs at Windows logon. If local script execution is disabled,
+leave the task disabled until the user permits locally authored scripts; do not
+bypass a managed execution policy. This does not start VMware or log into Windows.
+The VM and PC still need to be running.
+
+Tests: `node scripts/test-core.mjs`, TypeScript checking, and the production build.
+Native commands verify identity, availability and permissions again at delivery.
+A database snapshot should be taken before the first deployment.
diff --git a/scripts/operations-agent.py b/scripts/operations-agent.py
new file mode 100644
index 0000000..21bfb3a
--- /dev/null
+++ b/scripts/operations-agent.py
@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Local telemetry and bounded terminal-log retention. No character data is deleted."""
+import base64,json,os,shutil,subprocess,sys,time,urllib.request
+from pathlib import Path
+repo=Path(__file__).resolve().parents[1]
+lab=Path(os.environ.get('AZEROTHAI_PLAYABLE_ROOT',str(Path.home()/'azerothai-pc-lab')))
+def config(path):
+ out={}
+ for line in path.read_text().splitlines():
+  if '=' in line and not line.startswith('#'):
+   k,v=line.split('=',1);out[k]=v.strip().strip('"').strip("'")
+ return out
+cfg={**config(lab/'runtime.env'),**config(repo/'.dev.vars')}
+base='http://127.0.0.1:8787'
+def send(data):
+ request=urllib.request.Request(base+'/api/operations',data=json.dumps(data).encode(),headers={'Content-Type':'application/json','Authorization':'Bearer '+cfg['AUTONOMY_TOKEN']})
+ with urllib.request.urlopen(request,timeout=20) as r:assert r.status==200
+if len(sys.argv)==3 and sys.argv[1]=='--windows':
+ data=json.loads(base64.b64decode(sys.argv[2]));data['host']='windows';send(data);sys.exit(0)
+def bytes_in(path):
+ return sum(p.stat().st_size for p in path.rglob('*') if p.is_file()) if path.exists() else 0
+def cpu():
+ v=list(map(int,Path('/proc/stat').read_text().splitlines()[0].split()[1:]));return sum(v[:8]),v[3]+v[4]
+a=cpu();time.sleep(1);b=cpu();used=100*(1-(b[1]-a[1])/max(1,b[0]-a[0]))
+mem={line.split(':')[0]:int(line.split()[1])/1024 for line in Path('/proc/meminfo').read_text().splitlines()}
+model=False
+try:
+ u=cfg.get('LLM_URL','').rstrip('/')+'/api/tags'
+ with urllib.request.urlopen(u,timeout=5) as r:model=r.status==200
+except Exception:pass
+maintenance=[]
+# Copy/truncate preserves existing service file descriptors. Three bounded archives.
+paths=[lab/'autonomy.log',lab/'ale-relay.log',Path.home()/'azerothai-direct-runtime-live.log',lab/'operations.log']
+for log in paths:
+ if log.exists() and log.stat().st_size>10*1024*1024:
+  for n in [3,2]:
+   older=Path(str(log)+'.'+str(n-1))
+   if older.exists():older.replace(str(log)+'.'+str(n))
+  shutil.copy2(log,str(log)+'.1')
+  with log.open('r+') as f:f.truncate(0)
+  maintenance.append('Rotated '+log.name)
+# Only acknowledged transport data; never purge pending messages or lifecycle history.
+try:
+ state=json.load(urllib.request.urlopen(base+'/api/state',timeout=10));days=max(3,min(30,int(state.get('opsRetentionDays',7))))
+ env=os.environ.copy();env['MYSQL_PWD']=cfg['DOCKER_DB_ROOT_PASSWORD']
+ def sql(q):return subprocess.check_output(['docker','exec','-e','MYSQL_PWD','ac-database','mysql','-uroot','-N','-B','-e',q],env=env,text=True)
+ for table,column in [('azerothai_event_outbox','delivered_at'),('azerothai_result_outbox','delivered_at')]:
+  sql(f'DELETE FROM acore_auth.{table} WHERE {column} IS NOT NULL AND {column}<NOW()-INTERVAL 1 DAY LIMIT 2000')
+ sql(f'DELETE FROM acore_auth.azerothai_snapshot_archive WHERE created_at<NOW()-INTERVAL {days} DAY LIMIT 2000')
+ maintenance.append('Acknowledged transport and snapshot retention checked')
+except Exception as e:maintenance.append('Retention check needs attention: '+type(e).__name__)
+service=subprocess.run(['systemctl','--user','is-active','azerothai-runtime'],capture_output=True,text=True).stdout.strip()
+send({'host':'ubuntu','at':time.time(),'cpuPercent':max(0,min(100,used)),'memoryTotalMB':mem['MemTotal'],'memoryAvailableMB':mem['MemAvailable'],'diskFreeGB':shutil.disk_usage(repo).free/1024**3,'databaseMB':bytes_in(repo/'.wrangler/state/v3/d1')/1024**2,'logsMB':sum(p.stat().st_size for p in paths if p.exists())/1024**2,'modelAvailable':model,'runtimeService':service,'maintenance':'; '.join(maintenance)[:500]})
+print(time.strftime('%Y-%m-%dT%H:%M:%SZ',time.gmtime()),'telemetry and retention complete')
diff --git a/scripts/test-core.mjs b/scripts/test-core.mjs
index aa89814..3b1ff45 100644
--- a/scripts/test-core.mjs
+++ b/scripts/test-core.mjs
@@ -3,4 +3,4 @@ import {writeFileSync,mkdirSync} from 'node:fs';
 const result=spawnSync(process.execPath,['node_modules/typescript/bin/tsc','core/service.ts','core/seed.ts','core/ale.ts','core/conversation.ts','core/autonomy.ts','--types','@cloudflare/workers-types,node','--outDir','.test-build','--module','commonjs','--target','es2022','--moduleResolution','node','--esModuleInterop','--skipLibCheck','--strict'],{stdio:'inherit'});
 if(result.status)process.exit(result.status);
 mkdirSync('.test-build',{recursive:true});writeFileSync('.test-build/package.json','{"type":"commonjs"}');
-process.exit(spawnSync(process.execPath,['--test','tests/core.test.cjs','tests/hardcore.test.cjs','tests/living-world.test.cjs','tests/ale.test.cjs','tests/brains.test.cjs','tests/conversation.test.cjs','tests/autonomy.test.cjs'],{stdio:'inherit'}).status??1);
+process.exit(spawnSync(process.execPath,['--test','tests/core.test.cjs','tests/hardcore.test.cjs','tests/living-world.test.cjs','tests/ale.test.cjs','tests/brains.test.cjs','tests/conversation.test.cjs','tests/autonomy.test.cjs','tests/community.test.cjs'],{stdio:'inherit'}).status??1);
diff --git a/tests/community.test.cjs b/tests/community.test.cjs
new file mode 100644
index 0000000..d9eec26
--- /dev/null
+++ b/tests/community.test.cjs
@@ -0,0 +1,39 @@
+const {test}=require('node:test');
+const assert=require('node:assert/strict');
+const {partyDecision,bondEvidence,community,compileCommunityAction,observePresence,applyCooperation}=require('../.test-build/community.js');
+const now=()=>Date.now()/1000;
+function bot(id){return {id,name:id,status:'online',level:5,autonomy:{managed:true,characterGuid:id==='A'?1:2},personality:{sociability:60,activities:['quest']},relationships:[],memories:[],world:{at:now(),team:1,nearby:id==='A'?['B']:['A'],inCombat:false,groupNames:[],groupId:'',guildId:3,guildName:'Guild',guildRank:0,mapId:0,x:1,y:1}};}
+test('party acceptance respects faction, level, hostility, combat, and observation freshness',()=>{
+ const a=bot('A'),b=bot('B');assert.equal(partyDecision(a,b).accepted,true);
+ b.world.team=0;assert.equal(partyDecision(a,b).accepted,false);b.world.team=1;
+ b.level=55;assert.equal(partyDecision(a,b).accepted,false);b.level=5;
+ b.relationships=[{targetId:'A',affinity:-10}];assert.equal(partyDecision(a,b).accepted,false);b.relationships=[];
+ b.world.at=now()-150;assert.equal(partyDecision(a,b).accepted,false);b.world.at=now();
+ b.world.inCombat=true;assert.equal(partyDecision(a,b).accepted,false);
+});
+test('relationship evidence is reciprocal, replay safe, bounded, and excludes deaths',()=>{
+ const a=bot('A'),b=bot('B'),s={bots:[a,b]};
+ bondEvidence(s,'x',a,b,'Helped',3);bondEvidence(s,'x',a,b,'Helped',3);
+ assert.equal(a.relationships[0].affinity,3);assert.equal(b.relationships[0].affinity,3);
+ applyCooperation(s,{observedAt:now(),evidenceId:'q',characterGuid:1,peerGuid:2,cooperation:'quest',questId:5});
+ assert.equal(a.relationships[0].affinity,6);assert.equal(a.memories.length,1);
+ applyCooperation(s,{observedAt:now(),evidenceId:'q',characterGuid:1,peerGuid:2,cooperation:'quest',questId:5});assert.equal(a.memories.length,1);
+ b.status='dead';applyCooperation(s,{observedAt:now(),evidenceId:'q2',characterGuid:1,peerGuid:2,cooperation:'quest'});assert.equal(a.memories.length,1);
+});
+test('native commands protect human parties, cap party size, verify identities and enforce guild authority',()=>{
+ const a=bot('A'),b=bot('B');
+ const p=compileCommunityAction('party',a,b);assert.match(p,/Human party is protected/);assert.match(p,/GetMembersCount\(\)>=5/);assert.match(p,/GroupCreate/);assert.match(p,/GetGUIDLow\(\)~=2/);
+ const g=compileCommunityAction('recruit',a,b);assert.match(g,/GetGuildRank\(\)~=0/);assert.match(g,/Already belongs to a guild/);
+ assert.match(compileCommunityAction('leave',a),/Party changed/);
+});
+test('fresh movement snapshots update guild registry and stale snapshots cannot create stuck alerts',()=>{
+ const a=bot('A'),s={bots:[a]};a.world.at=now()-30;
+ observePresence(s,a,{observedAt:now(),team:1,x:10,y:20,mapId:0,guildId:3,guildName:'Guild',groupId:'',nearbyBots:'B'});
+ assert.equal(community(s).guilds[0].name,'Guild');const at=a.world.at;
+ observePresence(s,a,{observedAt:now()-500,team:1,x:2,y:2});assert.equal(a.world.at,at);
+});
+
+test('offline party members are protected when their identity cannot be checked live',()=>{
+ assert.match(compileCommunityAction('party',bot('A'),bot('B')),/Party has offline members/);
+ assert.match(compileCommunityAction('leave',bot('A')),/Party has offline members/);
+});
diff --git a/tests/conversation.test.cjs b/tests/conversation.test.cjs
index 389976e..3f7f562 100644
--- a/tests/conversation.test.cjs
+++ b/tests/conversation.test.cjs
@@ -2,6 +2,7 @@ const {test}=require('node:test');
 const assert=require('node:assert/strict');
 const queue=require('../.test-build/conversation-store.js');
 const ale=require('../.test-build/ale-store.js');
+require('../.test-build/community.js').communityTick=async()=>{};
 const {runConversationTick}=require('../.test-build/conversation.js');
 
 test('conversation failure, queued delivery, confirmed memory and replay safety',async()=>{
@@ -69,6 +70,7 @@ test('social exchanges remember both residents only after confirmed reply and re
   await runConversationTick(store,{},{});
   assert.equal(a.memories.length,1);assert.equal(b.memories.length,1);
   assert.equal(a.relationships[0].targetId,'b');assert.equal(b.relationships[0].targetId,'a');
+  assert.equal(a.relationships[0].affinity,1);assert.equal(b.relationships[0].affinity,1);
   await runConversationTick(store,{},{});
   assert.equal(a.memories.length,1);assert.equal(b.memories.length,1);assert.equal(followups,1);
  }finally{global.fetch=originalFetch;}

From 8e96c7ff479ebdc53f1c2955dcf0cb042a2f70a9 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 22 Sep 2026 18:15:35 -0400
Subject: [PATCH 11/13] Reconcile delayed hardcore deaths with native
 population registry

---
 ale/azerothai_lifecycle.lua      | 12 ++++++++++++
 docs/community-and-operations.md |  8 ++++++++
 scripts/operations-agent.py      | 21 +++++++++++++++++++++
 3 files changed, 41 insertions(+)

diff --git a/ale/azerothai_lifecycle.lua b/ale/azerothai_lifecycle.lua
index c6d3dfc..e4d303e 100644
--- a/ale/azerothai_lifecycle.lua
+++ b/ale/azerothai_lifecycle.lua
@@ -9,6 +9,7 @@ local TARGET_PER_FACTION = 25
 local gates = {}
 local gateAt = {}
 local arrivals = {}
+local reconciledAt = 0
 local alliance = {[1]=true,[3]=true,[4]=true,[7]=true,[11]=true}
 local horde = {[2]=true,[5]=true,[6]=true,[8]=true,[10]=true}
 local function faction(row)
@@ -77,6 +78,17 @@ end
 
 local function enforce()
  if not ready then reload() end
+ -- The dashboard may receive a verified death from an older transport backlog
+ -- after this process seeded its registry. Import terminal states only; never
+ -- overwrite a locally observed death with an older active database row.
+ if os.time()-reconciledAt>=10 then
+  local q=AuthDBQuery("SELECT guid,name,account_id FROM azerothai_lifecycle WHERE state='dead' AND protected=0 AND LOWER(name)<>'zaku'")
+  if q then repeat
+   local row=residents[q:GetUInt32(0)]
+   if row and not row.protected and row.name==q:GetString(1) and row.account==q:GetUInt32(2) then row.state="dead" end
+  until not q:NextRow() end
+  reconciledAt=os.time()
+ end
  local mgr=GetRandomPlayerbotMgr()
  -- Disallow every retired identity before the native manager fills vacancies.
  for guid,row in pairs(residents) do
diff --git a/docs/community-and-operations.md b/docs/community-and-operations.md
index 1bc5b3a..099134d 100644
--- a/docs/community-and-operations.md
+++ b/docs/community-and-operations.md
@@ -41,6 +41,14 @@ already does. Archived snapshots and terminal application commands use the chose
 state and memorials are preserved. Current application log files rotate at 10 MB
 with three copies. Database files may retain freed SQLite pages for reuse.
 
+The minute operations check also reconciles verified AzerothCore death records
+with the native hardcore registry using character GUID, account and exact name.
+Protected residents are excluded. Each correction keeps the old registry row
+and supporting death in `lifecycle-reconciliation.jsonl`. The Lua guard imports
+terminal registry states every ten seconds, removes the retired identity, and
+allows its faction's replacement slot to fill under the existing 25/25 cap.
+This handles delayed death events received after the registry was first seeded.
+
 Install `deploy/playable/install-user-recovery.py` as the realm owner. It registers
 `azerothai-runtime.service` with Restart=always and a minute operations timer in
 the user's systemd manager. Enable user lingering for reboot startup. Telemetry
diff --git a/scripts/operations-agent.py b/scripts/operations-agent.py
index 21bfb3a..0c5d923 100644
--- a/scripts/operations-agent.py
+++ b/scripts/operations-agent.py
@@ -44,6 +44,27 @@ try:
  state=json.load(urllib.request.urlopen(base+'/api/state',timeout=10));days=max(3,min(30,int(state.get('opsRetentionDays',7))))
  env=os.environ.copy();env['MYSQL_PWD']=cfg['DOCKER_DB_ROOT_PASSWORD']
  def sql(q):return subprocess.check_output(['docker','exec','-e','MYSQL_PWD','ac-database','mysql','-uroot','-N','-B','-e',q],env=env,text=True)
+ # Reconcile delayed verified deaths by the full native identity. This never
+ # revives an identity, changes a protected resident, or counts a human as a bot.
+ if state.get('settings',{}).get('hardcore',{}).get('enabled'):
+  retired=0
+  registry={int(line.split('\t')[0]):line for line in sql("SELECT guid,name,account_id,state,died_at FROM acore_auth.azerothai_lifecycle WHERE state<>'dead' AND protected=0 AND LOWER(name)<>'zaku'").splitlines() if line}
+  for bot in state.get('bots',[]):
+   identity=bot.get('autonomy') or {};death=bot.get('death') or {}
+   if bot.get('status')!='dead' or not death.get('verified') or death.get('source')!='azerothcore' or not identity.get('managed'):continue
+   if not bot.get('mortal') or bot.get('plotArmorHpFloor',0)>0 or bot.get('name','').lower()=='zaku':continue
+   guid=identity.get('characterGuid');account=identity.get('accountId')
+   if type(guid) is not int or type(account) is not int or guid<=0 or account<=0:continue
+   before=registry.get(guid,'');fields=before.split('\t')
+   if len(fields)!=5 or fields[1]!=bot['name'] or int(fields[2])!=account:continue
+   name=bot['name'].encode().hex()
+   where=f"guid={guid} AND account_id={account} AND BINARY name=UNHEX('{name}') AND protected=0 AND LOWER(name)<>'zaku' AND state<>'dead'"
+   # Keep an audit of the old registry row and supporting death before changing it.
+   audit=lab/'lifecycle-reconciliation.jsonl'
+   with audit.open('a') as f:f.write(json.dumps({'at':time.time(),'before':before.strip(),'death':death})+'\n')
+   changed=sql("UPDATE acore_auth.azerothai_lifecycle SET state='dead',died_at=COALESCE(died_at,NOW()) WHERE "+where+'; SELECT ROW_COUNT()')
+   retired+=int(changed.strip())
+  maintenance.append(f'Hardcore registry checked; {retired} delayed deaths reconciled')
  for table,column in [('azerothai_event_outbox','delivered_at'),('azerothai_result_outbox','delivered_at')]:
   sql(f'DELETE FROM acore_auth.{table} WHERE {column} IS NOT NULL AND {column}<NOW()-INTERVAL 1 DAY LIMIT 2000')
  sql(f'DELETE FROM acore_auth.azerothai_snapshot_archive WHERE created_at<NOW()-INTERVAL {days} DAY LIMIT 2000')

From 7e19d82a02e58b168e0cc6edfb82398ed5705c84 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 22 Sep 2026 19:50:05 -0400
Subject: [PATCH 12/13] Add isolated read-only spectator monitor for public
 sharing

---
 deploy/playable/install-spectator.py |  28 +++++
 docs/spectator-monitor.md            |  60 +++++++++
 scripts/spectator-server.py          | 176 +++++++++++++++++++++++++++
 scripts/test-spectator.py            |  57 +++++++++
 spectator/app.js                     |  46 +++++++
 spectator/index.html                 |  11 ++
 spectator/style.css                  |   1 +
 7 files changed, 379 insertions(+)
 create mode 100644 deploy/playable/install-spectator.py
 create mode 100644 docs/spectator-monitor.md
 create mode 100644 scripts/spectator-server.py
 create mode 100644 scripts/test-spectator.py
 create mode 100644 spectator/app.js
 create mode 100644 spectator/index.html
 create mode 100644 spectator/style.css

diff --git a/deploy/playable/install-spectator.py b/deploy/playable/install-spectator.py
new file mode 100644
index 0000000..8be673b
--- /dev/null
+++ b/deploy/playable/install-spectator.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+"""Install the isolated spectator service; public Funnel setup is a separate step."""
+from pathlib import Path
+import shutil
+import subprocess
+repo = Path(__file__).resolve().parents[2]
+python = shutil.which('python3')
+assert python
+units = Path.home() / '.config/systemd/user'
+units.mkdir(parents=True, exist_ok=True)
+(units / 'azerothai-spectator.service').write_text(f'''[Unit]
+Description=AzerothAI read-only spectator monitor
+After=network-online.target azerothai-runtime.service
+[Service]
+WorkingDirectory={repo}
+ExecStart={python} {repo}/scripts/spectator-server.py
+Restart=always
+RestartSec=5
+NoNewPrivileges=true
+UMask=0077
+[Install]
+WantedBy=default.target
+''')
+subprocess.run(['systemctl', '--user', 'daemon-reload'], check=True)
+subprocess.run(['systemctl', '--user', 'enable', '--now', 'azerothai-spectator.service'], check=True)
+print('Spectator ready on loopback port 8790. Public sharing:')
+print('sudo tailscale funnel --bg --https=8443 http://127.0.0.1:8790')
+print('Keep the existing private dashboard on port 443.')
diff --git a/docs/spectator-monitor.md b/docs/spectator-monitor.md
new file mode 100644
index 0000000..00a817e
--- /dev/null
+++ b/docs/spectator-monitor.md
@@ -0,0 +1,60 @@
+# Spectator monitor
+
+A separate loopback service serves a public, read-only projection of the realm.
+It never forwards viewer paths, methods, cookies, authorization headers or query
+parameters to the administrative application. It uses a fixed local GET to
+`http://127.0.0.1:8787/api/state`, caches the sanitized result for ten seconds, and
+marks delayed observations. Visitors refresh every fifteen seconds.
+
+Published fields: online bot names, class, race, level, faction, zone, guild;
+observed bot parties; guild goals and progress; confirmed social activity.
+Only autonomous bot-to-bot reply transcripts are public. Human conversations,
+whispers, memories, account/character IDs, tokens, configuration and PC telemetry
+are excluded. All text is rendered with textContent, never HTML interpolation.
+The HTTP service allows only explicit static paths and `/api/realm`, `/health`,
+`/robots.txt`. Mutation methods return 405; admin paths return 404.
+
+## Install and publish
+
+Run as the realm owner from the repository:
+
+```sh
+python3 scripts/test-spectator.py
+python3 deploy/playable/install-spectator.py
+```
+
+The user service restarts automatically and listens only on `127.0.0.1:8790`.
+User lingering, already used by runtime recovery, is required for boot startup.
+Keep the existing private Tailscale Serve dashboard on HTTPS 443. Publish only
+the spectator service on a separate HTTPS port:
+
+```sh
+sudo tailscale funnel --bg --https=8443 http://127.0.0.1:8790
+```
+
+If Tailscale presents a Funnel enablement link, the tailnet owner must complete
+that authorization. Verify `tailscale funnel status` lists **only port 8443** as
+public and port 443 remains tailnet-only. Share the printed HTTPS URL including
+`:8443`. Visitors do not need Tailscale. This is a public link, without a password.
+The host PC, Ubuntu VM and Tailscale must remain running.
+
+Do not publish port 8787 or 8788, or change the administrative listener into a
+Funnel. Hiding controls in the browser would not protect their APIs.
+
+To turn public access off without disturbing the private dashboard:
+
+```sh
+sudo tailscale funnel --https=8443 off
+```
+
+To stop the local spectator service:
+
+```sh
+systemctl --user disable --now azerothai-spectator
+```
+
+After changing spectator source or assets, restart its service:
+
+```sh
+systemctl --user restart azerothai-spectator
+```
diff --git a/scripts/spectator-server.py b/scripts/spectator-server.py
new file mode 100644
index 0000000..7fbd4fc
--- /dev/null
+++ b/scripts/spectator-server.py
@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""Read-only public realm projection. Never proxy arbitrary routes or headers."""
+import json
+import math
+import os
+import threading
+import time
+import urllib.request
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1] / 'spectator'
+ALLIANCE = {'Human', 'Dwarf', 'Night Elf', 'Gnome', 'Draenei'}
+HORDE = {'Orc', 'Undead', 'Tauren', 'Troll', 'Blood Elf'}
+
+
+def text(value, limit=200):
+    return str(value or '')[:limit]
+
+
+def number(value, default=0):
+    return value if type(value) in (int, float) and math.isfinite(value) else default
+
+
+def project(state):
+    """Explicit field allowlist: no settings, IDs, memories, whispers or host data."""
+    managed = [b for b in state.get('bots', []) if b.get('autonomy', {}).get('managed')]
+    names = {b['name'] for b in managed}
+    bots = []
+    parties = {}
+    for b in managed:
+        if b.get('status') != 'online':
+            continue
+        world = b.get('world') or {}
+        race = text(b.get('race'), 40)
+        team = world.get('team')
+        faction = ('Alliance' if team == 0 else 'Horde' if team == 1 else
+                   'Alliance' if race in ALLIANCE else 'Horde' if race in HORDE else 'Unknown')
+        bots.append({'name': text(b.get('name'), 40), 'class': text(b.get('role'), 40),
+                     'race': race, 'level': number(b.get('level')), 'zone': text(b.get('zone'), 100),
+                     'faction': faction, 'guild': text(world.get('guildName'), 80)})
+        members = sorted({text(n, 40) for n in world.get('groupNames', []) if n in names})
+        if world.get('groupId') and len(members) > 1:
+            parties[tuple(members)] = {'members': members, 'faction': faction}
+    community = state.get('community') or {}
+    feed = []
+    for e in community.get('feed', []):
+        if e.get('status') != 'confirmed' or e.get('kind') not in {'conversation', 'relationship', 'party', 'leave', 'recruit', 'guild'}:
+            continue
+        # Only completed autonomous bot-to-bot exchanges. Human conversations,
+        # whispers and synthetic opener prompts never enter this public feed.
+        if e['kind'] == 'conversation' and not (
+                str(e.get('id', '')).startswith('social-') and str(e.get('id', '')).endswith(':reply')
+                and len(e.get('names', [])) == 2 and all(n in names for n in e['names'])):
+            continue
+        feed.append({'at': text(e.get('at'), 40), 'kind': e['kind'],
+                     'names': [text(n, 80) for n in e.get('names', [])[:5]],
+                     'text': text(e.get('text'), 1200)})
+    guilds = [{'name': text(g.get('name'), 80), 'goal': text(g.get('goal'), 30),
+               'progress': number(g.get('progress')), 'target': number(g.get('target'), 20)}
+              for g in community.get('guilds', [])[:100]]
+    return {'rosterAt': number(state.get('aleRosterAt')), 'fetchedAt': int(time.time()),
+            'bots': sorted(bots, key=lambda b: (b['faction'], b['name'])),
+            'parties': list(parties.values()), 'guilds': guilds, 'feed': feed[-60:][::-1]}
+
+
+class Snapshot:
+    def __init__(self):
+        self.lock = threading.Lock()
+        self.data = None
+        self.checked = 0
+        self.failed = False
+
+    def get(self):
+        with self.lock:
+            if time.monotonic() - self.checked > 10:
+                try:
+                    # Fixed local endpoint. Viewer input cannot affect this request.
+                    opener = urllib.request.build_opener(NoRedirect(), urllib.request.ProxyHandler({}))
+                    with opener.open('http://127.0.0.1:8787/api/state', timeout=5) as response:
+                        raw = response.read(8 * 1024 * 1024 + 1)
+                        if len(raw) > 8 * 1024 * 1024:
+                            raise ValueError('State too large')
+                        self.data = project(json.loads(raw))
+                    self.failed = False
+                except Exception:
+                    self.failed = True
+                self.checked = time.monotonic()
+            if self.data is None:
+                return None
+            return {**self.data, 'stale': self.failed or time.time() - self.data['rosterAt'] > 120}
+
+
+class NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, *args, **kwargs):
+        return None
+
+
+SNAPSHOT = Snapshot()
+ASSETS = {'/': ('index.html', 'text/html; charset=utf-8'),
+          '/app.js': ('app.js', 'text/javascript; charset=utf-8'),
+          '/style.css': ('style.css', 'text/css; charset=utf-8')}
+
+
+class Handler(BaseHTTPRequestHandler):
+    server_version = 'AzerothAI-Spectator'
+    sys_version = ''
+
+    def setup(self):
+        super().setup()
+        self.connection.settimeout(10)
+
+    def reply(self, status, body, content_type='application/json; charset=utf-8'):
+        self.send_response(status)
+        self.send_header('Content-Type', content_type)
+        self.send_header('Content-Length', str(len(body)))
+        self.send_header('Cache-Control', 'no-store')
+        self.send_header('X-Content-Type-Options', 'nosniff')
+        self.send_header('X-Frame-Options', 'DENY')
+        self.send_header('Referrer-Policy', 'no-referrer')
+        self.send_header('X-Robots-Tag', 'noindex, nofollow')
+        self.send_header('Content-Security-Policy', "default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; img-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'")
+        self.end_headers()
+        if self.command != 'HEAD':
+            self.wfile.write(body)
+
+    def do_GET(self):
+        path = self.path.split('?', 1)[0]
+        if path in ASSETS:
+            filename, content_type = ASSETS[path]
+            self.reply(200, (ROOT / filename).read_bytes(), content_type)
+        elif path == '/api/realm':
+            data = SNAPSHOT.get()
+            self.reply(200 if data else 503, json.dumps(data or {'error': 'Realm temporarily unavailable'}).encode())
+        elif path == '/health':
+            self.reply(200, b'{"service":"spectator","readOnly":true}')
+        elif path == '/robots.txt':
+            self.reply(200, b'User-agent: *\nDisallow: /\n', 'text/plain; charset=utf-8')
+        else:
+            self.reply(404, b'{"error":"Not found"}')
+
+    do_HEAD = do_GET
+
+    def reject(self):
+        self.close_connection = True
+        self.reply(405, b'{"error":"This monitor is read-only"}')
+
+    do_POST = do_PUT = do_PATCH = do_DELETE = do_OPTIONS = do_TRACE = do_CONNECT = reject
+
+    def log_message(self, format, *args):
+        pass
+
+
+class Server(ThreadingHTTPServer):
+    daemon_threads = True
+    slots = threading.BoundedSemaphore(24)
+
+    def process_request(self, request, client_address):
+        if not self.slots.acquire(blocking=False):
+            self.shutdown_request(request)
+            return
+        try:
+            super().process_request(request, client_address)
+        except Exception:
+            self.slots.release()
+            raise
+
+    def process_request_thread(self, request, client_address):
+        try:
+            super().process_request_thread(request, client_address)
+        finally:
+            self.slots.release()
+
+
+if __name__ == '__main__':
+    Server(('127.0.0.1', int(os.environ.get('AZEROTHAI_SPECTATOR_PORT', '8790'))), Handler).serve_forever()
diff --git a/scripts/test-spectator.py b/scripts/test-spectator.py
new file mode 100644
index 0000000..6878938
--- /dev/null
+++ b/scripts/test-spectator.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+import importlib.util
+import json
+import threading
+import unittest
+import urllib.error
+import urllib.request
+from pathlib import Path
+spec = importlib.util.spec_from_file_location('spectator', Path(__file__).with_name('spectator-server.py'))
+m = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(m)
+
+
+class SpectatorTests(unittest.TestCase):
+    def test_public_projection_excludes_secrets_and_whispers(self):
+        bots = [{'name': n, 'status': 'online', 'race': r, 'role': 'Death Knight', 'level': 55,
+                 'autonomy': {'managed': True, 'accountId': 123}, 'memories': ['PRIVATE_MEMORY'],
+                 'world': {'team': team, 'groupId': 'internal-guid', 'groupNames': ['A', 'B', 'HumanPlayer']}}
+                for n, r, team in [('A', 'Human', 0), ('B', 'Orc', 1)]]
+        feed = [{'id': i, 'kind': 'conversation', 'status': 'confirmed', 'names': names, 'text': t}
+                for i, names, t in [('whisper-1', ['HumanPlayer', 'A'], 'PRIVATE_WHISPER'),
+                                   ('social-1', ['A', 'B'], 'SYNTHETIC_PROMPT'),
+                                   ('social-1:reply', ['A', 'B'], 'Hello friend'),
+                                   ('social-2:reply', ['HumanPlayer', 'A'], 'NOT_BOT_CHAT')]]
+        projected = m.project({'bots': bots, 'settings': {'token': 'SECRET'}, 'community': {'feed': feed}})
+        serialized = json.dumps(projected)
+        for private in ['PRIVATE_MEMORY', 'PRIVATE_WHISPER', 'SYNTHETIC_PROMPT', 'NOT_BOT_CHAT', 'HumanPlayer', 'SECRET', 'accountId', 'internal-guid']:
+            self.assertNotIn(private, serialized)
+        self.assertEqual([b['faction'] for b in projected['bots']], ['Alliance', 'Horde'])
+        self.assertEqual([e['text'] for e in projected['feed']], ['Hello friend'])
+
+    def test_http_allowlist_and_mutations(self):
+        server = m.Server(('127.0.0.1', 0), m.Handler)
+        worker = threading.Thread(target=server.serve_forever, daemon=True)
+        worker.start()
+        base = 'http://127.0.0.1:' + str(server.server_port)
+        try:
+            for route in ['/', '/app.js', '/style.css', '/health']:
+                with urllib.request.urlopen(base + route) as response:
+                    self.assertEqual(response.status, 200)
+                    self.assertIn("default-src 'none'", response.headers['Content-Security-Policy'])
+            for path in ['/api/state', '/api/actions', '/api/ale/operator', '/api/operations', '/.dev.vars', '/../.dev.vars', '/%2e%2e/.dev.vars', '//api/state']:
+                with self.assertRaises(urllib.error.HTTPError) as error:
+                    urllib.request.urlopen(base + path)
+                self.assertEqual(error.exception.code, 404)
+            for method in ['POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'TRACE']:
+                with self.assertRaises(urllib.error.HTTPError) as error:
+                    urllib.request.urlopen(urllib.request.Request(base + '/api/actions', method=method, data=b'{}'))
+                self.assertEqual(error.exception.code, 405)
+        finally:
+            server.shutdown()
+            server.server_close()
+            worker.join()
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/spectator/app.js b/spectator/app.js
new file mode 100644
index 0000000..aa40fc0
--- /dev/null
+++ b/spectator/app.js
@@ -0,0 +1,46 @@
+'use strict';
+const $ = id => document.getElementById(id);
+let realm;
+function el(tag, text, cls) { const node = document.createElement(tag); if (text !== undefined) node.textContent = String(text); if (cls) node.className = cls; return node; }
+function empty(node, text) { node.replaceChildren(el('p', text, 'empty')); }
+function renderRoster() {
+  if (!realm) return;
+  const term = $('search').value.trim().toLowerCase(), faction = $('faction').value;
+  const bots = realm.bots.filter(b => (faction === 'all' || b.faction === faction) && [b.name,b.class,b.race,b.zone,b.guild].join(' ').toLowerCase().includes(term));
+  $('roster').replaceChildren(...bots.map(b => {
+    const row = el('tr'); row.append(el('td', b.name));
+    const team = el('td'); team.append(el('span', b.faction, 'tag ' + b.faction.toLowerCase())); row.append(team);
+    const role = el('td', b.class); role.append(el('small', b.race)); row.append(role, el('td', b.level), el('td', b.zone || 'Unknown'), el('td', b.guild || '—')); return row;
+  }));
+  $('roster-empty').hidden = bots.length > 0;
+  $('roster-empty').textContent = realm.bots.length ? 'No residents match this search.' : 'No residents are currently reported online.';
+}
+function renderFeed() {
+  if (!realm) return;
+  const entries = realm.feed.filter(e => $('activity-filter').value === 'all' || e.kind === $('activity-filter').value);
+  if (!entries.length) return empty($('feed'), 'No confirmed activity of this type yet. New encounters will appear here.');
+  $('feed').replaceChildren(...entries.map(e => {
+    const node = el('article', undefined, 'entry');
+    node.append(el('span', e.kind + ' · ' + new Date(e.at).toLocaleString(), 'meta'), el('h3', e.names.join(' ↔ ')), el('p', e.text)); return node;
+  }));
+}
+function render() {
+  $('total').textContent = realm.bots.length;
+  $('alliance').textContent = realm.bots.filter(b => b.faction === 'Alliance').length;
+  $('horde').textContent = realm.bots.filter(b => b.faction === 'Horde').length;
+  $('parties-count').textContent = realm.parties.length;
+  $('status').className = 'status' + (realm.stale ? ' stale' : '');
+  $('status').textContent = (realm.stale ? 'Updates delayed · Showing last known roster' : 'Live realm observations') + (realm.rosterAt ? ' · Observed ' + new Date(realm.rosterAt * 1000).toLocaleTimeString() : '');
+  renderRoster(); renderFeed();
+  $('parties').replaceChildren(...realm.parties.map(p => { const n=el('article',undefined,'group');n.append(el('strong',p.members.join(' · ')),el('p',p.faction));return n; }));
+  if (!realm.parties.length) empty($('parties'), 'No bot parties observed yet.');
+  const goals={quest:'Complete quests together',support:'Help guildmates in combat',explore:'Explore other maps'};
+  $('guilds').replaceChildren(...realm.guilds.map(g => { const n=el('article',undefined,'group');n.append(el('strong',g.name),el('p',goals[g.goal]||'Shared adventures'),el('p',g.progress+' contributions · milestone '+g.target));const p=el('progress');p.max=Math.max(1,g.target);p.value=g.progress;p.setAttribute('aria-label',g.name+' goal progress');n.append(p);return n; }));
+  if (!realm.guilds.length) empty($('guilds'), 'Waiting for guild observations.');
+}
+async function refresh() {
+  try { const response=await fetch('/api/realm',{cache:'no-store',signal:AbortSignal.timeout(10000)});if(!response.ok)throw new Error();realm=await response.json();render(); }
+  catch { $('status').className='status stale';$('status').textContent=realm?'Connection interrupted · Showing the last observation. Retrying automatically.':'Realm temporarily unavailable. Retrying automatically.'; }
+  finally { setTimeout(refresh,15000); }
+}
+$('search').addEventListener('input',renderRoster);$('faction').addEventListener('change',renderRoster);$('activity-filter').addEventListener('change',renderFeed);refresh();
diff --git a/spectator/index.html b/spectator/index.html
new file mode 100644
index 0000000..806fb92
--- /dev/null
+++ b/spectator/index.html
@@ -0,0 +1,11 @@
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="color-scheme" content="dark"><title>AzerothAI · Living Realm</title><link rel="stylesheet" href="/style.css"><script src="/app.js" defer></script></head>
+<body><main>
+<header><div><p class="eyebrow">AZEROTHAI / SPECTATOR</p><h1>A world with a life of its own.</h1><p class="intro">Follow the residents of Azeroth as they adventure, meet, and build a shared history.</p></div><span class="badge">View only</span></header>
+<div class="status" role="status" id="status">Connecting to the realm…</div>
+<section class="stats" aria-label="Realm population"><article><span>Residents online</span><strong id="total">—</strong><small>50 resident limit</small></article><article class="alliance"><span>Alliance</span><strong id="alliance">—</strong><small>25 resident target</small></article><article class="horde"><span>Horde</span><strong id="horde">—</strong><small>25 resident target</small></article><article><span>Adventuring parties</span><strong id="parties-count">—</strong><small>Observed bot groups</small></article></section>
+<nav aria-label="Realm sections"><a href="#residents">Residents</a><a href="#activity">Social life</a><a href="#groups">Parties & guilds</a></nav>
+<section id="residents" class="panel"><div class="heading"><div><p class="eyebrow">IN THE WORLD</p><h2>Meet the residents</h2></div><div class="filters"><label><span class="sr-only">Search residents</span><input id="search" type="search" placeholder="Find a name, class, or zone…"></label><label><span class="sr-only">Faction</span><select id="faction"><option value="all">Both factions</option><option>Alliance</option><option>Horde</option></select></label></div></div><div class="table-wrap"><table><thead><tr><th>Name</th><th>Faction</th><th>Class / race</th><th>Level</th><th>Location</th><th>Guild</th></tr></thead><tbody id="roster"></tbody></table></div><p id="roster-empty" class="empty">Waiting for the first observation.</p></section>
+<div class="columns"><section id="activity" class="panel"><div class="heading"><div><p class="eyebrow">SHARED STORIES</p><h2>Social life</h2></div><label><span class="sr-only">Activity type</span><select id="activity-filter"><option value="all">All activity</option><option value="conversation">Conversations</option><option value="relationship">Relationships</option></select></label></div><div id="feed" class="feed"></div></section><section id="groups" class="panel"><div class="heading"><div><p class="eyebrow">BETTER TOGETHER</p><h2>Parties & guilds</h2></div></div><div class="group-body"><h3>Current parties</h3><div id="parties"></div><h3 class="guild-title">Guild ambitions</h3><div id="guilds"></div></div></section></div>
+<footer>Automatic updates every 15 seconds · Population can briefly dip while a replacement joins.<br>Bot-to-bot conversations only. Player whispers stay private.</footer>
+</main></body></html>
diff --git a/spectator/style.css b/spectator/style.css
new file mode 100644
index 0000000..5c86a27
--- /dev/null
+++ b/spectator/style.css
@@ -0,0 +1 @@
+:root{font-family:system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;color:#e6e8ed;background:#0b1017;font-synthesis:none}*{box-sizing:border-box}body{margin:0;background:radial-gradient(ellipse at 15% 0,#23314455,transparent 55%)}main{max-width:1280px;margin:auto;padding:48px 28px}header{display:flex;justify-content:space-between;gap:24px;align-items:flex-start}h1{font-family:Georgia,serif;font-size:clamp(30px,4vw,48px);font-weight:400;letter-spacing:-1px;margin:12px 0}h2{font-size:22px;margin:5px 0}h3{font-size:15px;margin:0 0 14px}.eyebrow{font-size:11px;letter-spacing:2px;color:#c3a56f;margin:0}.intro{max-width:640px;color:#a9b2c1;line-height:1.7}.badge{border:1px solid #415245;border-radius:30px;color:#a8c8a5;white-space:nowrap;padding:8px 14px;font-size:12px}.status{color:#a9b2c1;margin:20px 0;font-size:13px}.status.stale{color:#f2bd79}.stats{display:grid;grid-template-columns:repeat(4,1fr);gap:16px}.stats article{background:#121a25;border:1px solid #293241;border-radius:14px;padding:22px;display:flex;flex-direction:column;gap:6px}.stats span{font-size:13px;color:#bec7d3}.stats strong{font-size:40px;font-weight:500;color:#dcc18e}.stats small{font-size:11px;color:#8e9aaa}.stats .alliance strong{color:#8dbbff}.stats .horde strong{color:#ef9995}nav{display:flex;gap:25px;padding:26px 0}a{color:#bcc7d5;text-decoration:none;font-size:14px}a:hover{color:#efd69f}.panel{background:#111923;border:1px solid #293241;border-radius:14px;overflow:hidden;scroll-margin-top:20px}.heading{padding:24px;display:flex;align-items:center;justify-content:space-between;gap:18px;border-bottom:1px solid #27303c}.filters{display:flex;gap:8px}input,select{font:inherit;font-size:13px;background:#0c131c;border:1px solid #354153;color:#dfe5ec;padding:11px;border-radius:7px}input{width:250px}input:focus,select:focus,a:focus-visible{outline:2px solid #c3a56f;outline-offset:3px}.table-wrap{overflow-x:auto}table{width:100%;border-collapse:collapse;text-align:left;white-space:nowrap}th{font-size:10px;text-transform:uppercase;letter-spacing:1px;color:#919eaf;padding:15px 22px}td{font-size:13px;padding:15px 22px;border-top:1px solid #202b38;color:#b5c0ce}td:first-child{color:#eee6d9;font-weight:600}td small{display:block;color:#8b98aa;font-size:11px;margin-top:4px}.tag{font-size:11px;border-radius:4px;padding:4px 7px;background:#263347;color:#a6c8fb}.tag.horde{background:#38282e;color:#eab0a7}.columns{display:grid;grid-template-columns:1.25fr 1fr;gap:22px;margin-top:22px;align-items:start}.feed{max-height:660px;overflow-y:auto;padding:0 24px}.entry{padding:22px 0;border-bottom:1px solid #293241}.entry:last-child{border:0}.entry .meta{font-size:10px;color:#a6b0bd;text-transform:uppercase;letter-spacing:.8px}.entry h3{margin:10px 0;color:#d8c19a}.entry p{font-size:14px;line-height:1.7;white-space:pre-wrap;margin:0;color:#b6c1d0;overflow-wrap:anywhere}.group-body{padding:24px}.group{background:#17212e;border-radius:9px;padding:16px;margin-bottom:12px;font-size:14px;line-height:1.6}.group strong{display:block;color:#dfcfb2}.group p{font-size:12px;color:#aab7c8;margin:5px 0}.guild-title{margin-top:30px}progress{width:100%;height:6px;accent-color:#bea573}.empty{color:#95a2b4;font-size:13px;line-height:1.7;padding:20px;margin:0}footer{margin-top:30px;color:#8593a6;font-size:12px;line-height:1.9}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}@media(max-width:850px){.columns{grid-template-columns:1fr}.heading{align-items:flex-start;flex-direction:column}.filters{width:100%}input{width:100%}.filters label:first-child{flex:1}}@media(max-width:540px){main{padding:28px 16px}.stats{grid-template-columns:1fr 1fr;gap:10px}.stats article{padding:17px}.stats strong{font-size:34px}header{display:block}.badge{display:inline-block;margin-top:8px}.heading{padding:20px}.filters{flex-direction:column}select{max-width:100%}nav{gap:20px}nav a{font-size:13px}}

From 210b715a6f34eaaac7a71760304423993fb1df32 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 22 Sep 2026 20:18:00 -0400
Subject: [PATCH 13/13] Share admin dashboard views through isolated read-only
 visitor access

---
 app/globals.css             |  2 +
 app/page.tsx                | 37 +++++++--------
 app/visitor/page.tsx        |  3 ++
 docs/spectator-monitor.md   | 25 +++++++++-
 scripts/spectator-server.py | 91 +++++++++++++++++++++++++++++++++++--
 scripts/test-spectator.py   | 20 ++++++--
 6 files changed, 152 insertions(+), 26 deletions(-)
 create mode 100644 app/visitor/page.tsx

diff --git a/app/globals.css b/app/globals.css
index 99802d5..2bc31c3 100644
--- a/app/globals.css
+++ b/app/globals.css
@@ -6,3 +6,5 @@
 *{box-sizing:border-box}body{margin:0;background:var(--background);color:var(--foreground);font-family:Arial,Helvetica,sans-serif;font-size:16px}button,input,textarea{font:inherit}button{cursor:pointer}button:disabled{cursor:not-allowed}h1,h2,h3,p{margin:0}h1{font:500 34px Georgia,serif;letter-spacing:.01em}h2{font-size:17px;font-weight:600}h3{font-size:16px;font-weight:600}small{font-size:13px;color:var(--muted)}svg{flex-shrink:0}.app-main{flex:1;min-width:0}.brand{display:flex;align-items:center;gap:12px;padding:27px 22px 25px}.brand-mark{font:38px Georgia,serif;color:#e3bb70}.brand strong{font:26px Georgia,serif;color:#e3bb70}.brand small{display:block;letter-spacing:2px;font-size:10px;margin-top:6px}.nav-section{color:#6f829b;letter-spacing:1.8px;font-size:11px;padding:24px 16px 10px}.nav-button{height:45px!important;margin-bottom:4px;padding:0 14px!important;font-size:14px!important}.nav-button svg{width:18px!important;height:18px!important}.sidebar-bottom{border-top:1px solid var(--border);padding:20px;margin:16px 8px 0;line-height:1.6;font-size:13px;color:var(--muted)}.topbar{height:65px;display:flex;align-items:center;justify-content:space-between;border-bottom:1px solid var(--border);padding:0 32px;background:#0d1622}.crumb{color:var(--muted);font-size:14px;display:flex;align-items:center;gap:12px}.top-right{display:flex;align-items:center;gap:16px;font-size:13px}.sim-badge{color:#e3bb70;border:1px solid #715b30;background:#30271b;padding:5px 10px;border-radius:5px;font-size:12px;white-space:nowrap}.content{padding:30px 32px;max-width:1800px;margin:auto}.page-heading{display:flex;justify-content:space-between;gap:20px;align-items:center;margin-bottom:26px}.eyebrow{font-size:11px;letter-spacing:2px;color:#c7a667;text-transform:uppercase;margin-bottom:9px}.subtitle{color:var(--muted);font-size:14px;margin-top:9px;line-height:1.6}.actions{display:flex;align-items:center;gap:9px;flex-wrap:wrap}.panel{background:linear-gradient(125deg,#121e2d,#0e1824);border:1px solid var(--border);border-radius:8px;overflow:hidden}.panel-head{padding:18px 21px;display:flex;align-items:center;justify-content:space-between;gap:12px;border-bottom:1px solid var(--border)}.panel-head h2{display:flex;gap:10px;align-items:center}.panel-head svg{color:#93a9c8;width:18px}.panel-body{padding:21px}.stats{display:grid;grid-template-columns:repeat(4,1fr);gap:16px;margin-bottom:23px}.stat{padding:21px;position:relative}.stat-label{font-size:14px;color:var(--muted);display:flex;align-items:center;justify-content:space-between}.stat-value{font-size:32px;font-weight:600;margin:13px 0 7px;font-variant-numeric:tabular-nums}.stat small{font-size:12px}.stat svg{color:#7aa4df;width:20px}.dashboard-grid{display:grid;grid-template-columns:minmax(0,1.55fr) minmax(280px,1fr);gap:22px}.span-all{grid-column:1/-1}.director-strip{background:linear-gradient(110deg,#243143,#141f2c);border-color:#526072;display:flex;justify-content:space-between;align-items:center;gap:20px;padding:24px;margin-bottom:23px}.director-strip h2{font:22px Georgia,serif;margin-bottom:9px}.director-strip p{font-size:14px;line-height:1.6;color:#b0bfd1}.director-icon{width:48px;height:48px;color:#e3bb70;flex-shrink:0}.director-content{display:flex;align-items:center;gap:20px}.tag{display:inline-block;border:1px solid #314a67;border-radius:4px;padding:3px 7px;font-size:12px;color:#9cbdee;background:#192b42}.tag.online{color:#80d9af;border-color:#285e49;background:#15372d}.tag.paused{color:#e0bf78;border-color:#5a4c2d;background:#302a1f}.tag.offline,.tag.retired{color:#a1aec1;background:#202937;border-color:#394251}.event-row{display:grid;grid-template-columns:51px 77px 1fr;gap:12px;align-items:start;font-size:14px;line-height:1.5;padding:15px 20px;border-bottom:1px solid #202d3c}.event-row:last-child{border:0}.event-time{font:12px monospace;color:#788da6;padding-top:4px}.event-kind{font-size:11px;line-height:24px;color:#98b9ef;text-transform:capitalize}.event-kind.error{color:#fb8994}.event-kind.memory{color:#b8a5e8}.event-kind.lifecycle{color:#7ec9aa}.bot-name{display:flex;align-items:center;gap:12px}.avatar{width:37px;height:40px;border:1px solid #526084;border-radius:7px;display:grid;place-items:center;font:20px Georgia,serif;color:#c7b7ee;background:linear-gradient(140deg,#333555,#19263b)}.avatar.Warrior,.avatar.Paladin{color:#e3bb70;border-color:#786040;background:linear-gradient(140deg,#453a2b,#282b32)}.avatar.Rogue{color:#88cba9;border-color:#3b715e}.bot-name strong{font-size:14px}.bot-name small{display:block;margin-top:4px;font-size:12px}.data-table th{font-size:11px;text-transform:uppercase;letter-spacing:1px;color:#8297b1;padding:14px 20px}.data-table td{padding:15px 20px;font-size:14px}.data-table tbody tr{cursor:pointer}.data-table tbody tr:hover{background:#192738}.recipe-grid{display:grid;grid-template-columns:repeat(2,1fr);gap:18px}.recipe-card{padding:22px;cursor:pointer;text-align:left;width:100%;transition:border-color .2s}.recipe-card:hover{border-color:#7093c5}.recipe-card h3{margin:14px 0 10px}.recipe-card p{color:var(--muted);font-size:14px;line-height:1.6;min-height:46px}.recipe-card .tags{margin-top:18px;display:flex;gap:6px;flex-wrap:wrap}.recipe-symbol{width:40px;height:40px;border:1px solid #4b5674;background:#202c40;display:grid;place-items:center;border-radius:8px;color:#b5c9eb}.section-grid{display:grid;grid-template-columns:1fr 1fr;gap:22px}.form-grid{display:grid;grid-template-columns:1fr 1fr;gap:17px}.field{display:flex;flex-direction:column;gap:8px;font-size:14px}.field.full{grid-column:1/-1}.field input,.field textarea{background:#0b1420;border:1px solid #35465c;border-radius:5px;padding:10px;width:100%;color:#e1e9f4}.field textarea{min-height:84px;resize:vertical}.field [data-slot=select-trigger]{width:100%;height:42px;background:#0b1420}.form-footer{display:flex;justify-content:flex-end;gap:10px;margin-top:23px}.range-label{display:flex;justify-content:space-between;font-size:14px;margin-bottom:13px}.range-row{margin:18px 0}.choice-row{display:flex;align-items:center;gap:10px;font-size:14px}.choices{display:grid;grid-template-columns:1fr 1fr;gap:14px}.detail-header{padding:24px 0;display:flex;gap:16px;align-items:center}.detail-header .avatar{width:57px;height:63px;font-size:30px}.detail-header h2{font:27px Georgia,serif}.detail-block{padding:20px 0;border-bottom:1px solid var(--border)}.detail-block h3{margin-bottom:13px}.detail-block p{font-size:14px;color:#b1bfd0;line-height:1.7}.memory{padding:13px;background:#0c1622;border-left:2px solid #8c79b5;margin:12px 0}.memory small{display:block;margin-top:7px}.list-muted{color:var(--muted);font-size:14px;line-height:1.7}.zone-row{display:flex;align-items:center;gap:15px;font-size:14px;margin-bottom:20px}.zone-row .bar{flex:1;height:5px;background:#243449;border-radius:5px}.zone-row .bar i{display:block;height:100%;background:#759acc;border-radius:5px}.zone-row .zone-label{width:116px}.engine-box{display:flex;gap:14px;padding:18px;border:1px solid var(--border);border-radius:6px;margin-bottom:15px}.engine-box svg{color:#d2af73}.engine-box p{font-size:14px;color:var(--muted);line-height:1.6;margin-top:6px}.notice{padding:15px 18px;background:#1e2939;border:1px solid #3b506a;border-radius:6px;font-size:14px;line-height:1.6;color:#b7c8df;margin-bottom:20px}.empty-note{padding:32px;text-align:center;color:var(--muted)}.toolbar{display:flex;gap:12px;align-items:center;margin-bottom:20px}.toolbar input{max-width:330px}.health-row{display:flex;justify-content:space-between;padding:12px 0;font-size:14px;border-bottom:1px solid var(--border)}.health-row span{color:var(--muted)}.status-message{margin-top:15px;color:#b7c8df;font-size:14px}.fineprint{font-size:12px;line-height:1.7;color:#8296b0;margin-top:16px}.mobile-trigger{display:none}.screen-loading{padding:40px}.mobile-zone{display:none}@media(max-width:1100px){.content{padding:24px}.dashboard-grid{grid-template-columns:1fr}.stats{gap:10px}.stat{padding:16px}.section-grid{grid-template-columns:1fr}.director-strip{align-items:flex-start}.topbar{padding:0 24px}}@media(max-width:767px){.mobile-trigger{display:inline-flex}.content{padding:20px 15px}.topbar{padding:0 15px}.top-right>span:last-child{display:none}.page-heading{align-items:flex-start;flex-direction:column;gap:15px}h1{font-size:29px}.stats{grid-template-columns:1fr 1fr}.stat-value{font-size:27px}.director-strip{flex-direction:column;padding:18px}.director-icon{display:none}.recipe-grid,.form-grid{grid-template-columns:1fr}.field.full{grid-column:auto}.event-row{grid-template-columns:42px 1fr;gap:8px}.event-kind{display:none}.recipe-card p{min-height:0}.topbar .crumb{font-size:12px}.panel-head{padding:16px}.panel-body{padding:17px}}
 .gm-preview{font-family:monospace;font-size:13px;line-height:1.8;margin:20px 0;padding:16px;background:#080e17;border-left:2px solid #688ee3}.gm-preview span{color:#79a9ff}.gm-preview code{color:#b7bfce}.console-output{min-height:390px;max-height:570px;overflow:auto;background:#060c14;padding:25px;font:14px/1.7 monospace}.console-welcome{color:#79a7f5;letter-spacing:1px;margin-bottom:20px}.console-welcome span{color:#a0adc1;font-size:12px;letter-spacing:0}.console-muted{color:#788ba6;margin-bottom:20px}.console-entry{border-top:1px solid #1c2737;padding:14px 0;color:#9ccef2}.console-entry pre{white-space:pre-wrap;overflow-wrap:anywhere;font:13px/1.7 monospace;margin-top:8px}.console-error{color:#ec8e9c}.console-input{display:flex;gap:10px;align-items:center;padding:16px;background:#101b29}.console-input>span{color:#83adf8;font:20px monospace}.console-input input{font-family:monospace}.gm-shortcut{display:flex;justify-content:space-between;gap:15px;border:1px solid #2b3a4e;border-radius:5px;padding:12px;width:100%;margin-bottom:10px;font-size:14px;text-align:left}.gm-shortcut:hover{background:#203047}.gm-shortcut code{font-size:12px;color:#8eafe4}
 *,::before,::after{border-color:var(--border)}
+
+.readonly-fieldset{border:0;padding:0;margin:0;min-width:0}fieldset[disabled] button,fieldset[disabled] input,fieldset[disabled] textarea{cursor:default}
diff --git a/app/page.tsx b/app/page.tsx
index 036810e..3704a6e 100644
--- a/app/page.tsx
+++ b/app/page.tsx
@@ -24,45 +24,46 @@ const options=(items:string[])=>items.map(value=>({value,label:value}));
 function Avatar({bot}:{bot:Bot}){return <div className={`avatar ${bot.role}`} aria-hidden="true">{bot.name.slice(0,1)}</div>}
 function Panel({title,icon:Icon,children,action,className=''}:any){return <section className={`panel ${className}`}><div className="panel-head"><h2>{Icon&&<Icon/>}{title}</h2>{action}</div>{children}</section>}
 function Events({events}:{events:RealmEvent[]}){return <div>{events.length?[...events].reverse().map(e=><div className="event-row" key={e.id}><span className="event-time">{new Date(e.at).toLocaleTimeString([],{hour:'2-digit',minute:'2-digit'})}</span><span className={`event-kind ${e.kind}`}>{e.kind}</span><span>{e.message}</span></div>):<div className="empty-note">No events match this filter.</div>}</div>}
-export default function Home(){
+export default function Home({readOnly=false}:{readOnly?:boolean}){
  const [state,setState]=useState<State|null>(null),[page,setPage]=useState('Dashboard'),[error,setError]=useState(''),[busy,setBusy]=useState(false),[query,setQuery]=useState(''),[filter,setFilter]=useState('all'),[botId,setBotId]=useState<string|null>(null),[createOpen,setCreateOpen]=useState(false),[recipe,setRecipe]=useState<Recipe|null>(null),[recipeOpen,setRecipeOpen]=useState(false),[confirm,setConfirm]=useState<{title:string;description:string;action:any}|null>(null),[capabilities,setCapabilities]=useState<any>({}),[monitor,setMonitor]=useState<any>(null);
  const refresh=useCallback(async()=>{try{const r=await fetch('/api/state');const d:any=await r.json();if(!r.ok)throw new Error(d.error);setState(d);setError('');}catch(e){setError(e instanceof Error?e.message:'Could not load realm');}},[]);
  useEffect(()=>{void refresh();void fetch('/api/health').then(r=>r.json()).then(setCapabilities).catch(()=>{});const timer=setInterval(refresh,5000);return()=>clearInterval(timer);},[refresh]);
  useEffect(()=>{if(page!=='World Monitor')return;let cancelled=false;const load=async()=>{try{const r=await fetch('/api/world-monitor');const d=await r.json();if(!cancelled)setMonitor(d);}catch{if(!cancelled)setMonitor(null);}};void load();const timer=setInterval(load,3000);return()=>{cancelled=true;clearInterval(timer);};},[page]);
- const act=useCallback(async(action:any)=>{setBusy(true);try{const r=await fetch('/api/actions',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(action)});const d:any=await r.json();if(!r.ok)throw new Error(d.error);await refresh();return d;}catch(e){toast.error(e instanceof Error?e.message:'Action failed');await refresh();throw e;}finally{setBusy(false);}},[refresh]);
+ const act=useCallback(async(action:any)=>{if(readOnly)throw new Error('Visitor access is read-only');setBusy(true);try{const r=await fetch('/api/actions',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(action)});const d:any=await r.json();if(!r.ok)throw new Error(d.error);await refresh();return d;}catch(e){toast.error(e instanceof Error?e.message:'Action failed');await refresh();throw e;}finally{setBusy(false);}},[refresh,readOnly]);
  const perform=(action:any)=>{void act(action).catch(()=>{});};
- useEffect(()=>{const context=(document as any).modelContext;if(!context?.registerTool)return;const controller=new AbortController();const register=(tool:any)=>{try{Promise.resolve(context.registerTool(tool,{signal:controller.signal})).catch(()=>{});}catch{}};
+ useEffect(()=>{if(readOnly)return;const context=(document as any).modelContext;if(!context?.registerTool)return;const controller=new AbortController();const register=(tool:any)=>{try{Promise.resolve(context.registerTool(tool,{signal:controller.signal})).catch(()=>{});}catch{}};
  register({name:'azerothai_read_realm',description:'Read current bot identities, recipes, director settings and recent events.',inputSchema:{type:'object',properties:{},additionalProperties:false},annotations:{readOnlyHint:true},execute:async()=>{const r=await fetch('/api/state');if(!r.ok)throw new Error('Realm unavailable');return r.json();}});
- register({name:'azerothai_create_bot',description:'Create an offline bot identity; does not spawn it in game.',inputSchema:{type:'object',properties:{name:{type:'string'},role:{type:'string'},race:{type:'string'},recipeId:{type:'string'},goal:{type:'string'}},required:['name','role','race','recipeId','goal'],additionalProperties:false},annotations:{readOnlyHint:false},execute:async(input:any)=>act({...input,type:'createBot'})});return()=>controller.abort();},[act]);
+ register({name:'azerothai_create_bot',description:'Create an offline bot identity; does not spawn it in game.',inputSchema:{type:'object',properties:{name:{type:'string'},role:{type:'string'},race:{type:'string'},recipeId:{type:'string'},goal:{type:'string'}},required:['name','role','race','recipeId','goal'],additionalProperties:false},annotations:{readOnlyHint:false},execute:async(input:any)=>act({...input,type:'createBot'})});return()=>controller.abort();},[act,readOnly]);
  function nav(p:string){setPage(p);setQuery('');setFilter('all');}
  const selected=state?.bots.find(b=>b.id===botId);
  const visible=state?.bots.filter(b=>(`${b.name} ${b.role} ${b.zone}`.toLowerCase().includes(query.toLowerCase()))&&(filter==='all'||b.status===filter))??[];
  function botTable(bots:Bot[]){return <Table className="data-table"><TableHeader><TableRow><TableHead>Character</TableHead><TableHead>Status</TableHead><TableHead>Location</TableHead><TableHead>Recipe</TableHead><TableHead/></TableRow></TableHeader><TableBody>{bots.map(b=><TableRow key={b.id} onClick={()=>setBotId(b.id)}><TableCell><div className="bot-name"><Avatar bot={b}/><div><button onClick={()=>setBotId(b.id)}><strong>{b.name}</strong></button><small>Lv. {b.level} · {b.race} {b.role}</small></div></div></TableCell><TableCell><span className={`tag ${b.status}`}>{b.status}</span></TableCell><TableCell>{b.zone}</TableCell><TableCell><small>{b.personality.name.replace('The ','')}</small></TableCell><TableCell><ArrowRight size={15}/></TableCell></TableRow>)}</TableBody></Table>}
- return <SidebarProvider style={{'--sidebar-width':'228px'} as React.CSSProperties}><Sidebar><SidebarHeader className="p-0"><div className="brand"><span className="brand-mark">A</span><div><strong>AzerothAI</strong><small>YOUR WORLD. ALIVE.</small></div></div></SidebarHeader><SidebarContent className="px-3"><div className="nav-section">REALM MANAGEMENT</div><SidebarMenu>{NAV.map(([name,Icon])=><SidebarMenuItem key={name}><SidebarMenuButton className="nav-button" isActive={page===name} onClick={()=>nav(name)}><Icon/><span>{name}</span></SidebarMenuButton></SidebarMenuItem>)}</SidebarMenu></SidebarContent><SidebarFooter><div className="sidebar-bottom"><Shield size={20} color="#d9b77a"/><p style={{marginTop:10,color:'#d6dfec'}}>Realm administrator</p><small>Prototype 0.1 · Private realm</small><p style={{marginTop:20,fontFamily:'Georgia',fontStyle:'italic'}}>“What if Azeroth never felt empty?”</p></div></SidebarFooter></Sidebar><main className="app-main"><header className="topbar"><div className="crumb"><SidebarTrigger className="mobile-trigger"/>Living Realm <span>/</span> <span style={{color:'#d8e2f0'}}>{page}</span></div><div className="top-right"><span className="sim-badge">{capabilities.aleActiveRecently?'AZEROTHCORE LIVE':state?.settings.connector==='azerothcore'?'AzerothCore bridge':'SIMULATION REALM'}</span><span>GM workspace</span></div></header><div className="content">
- <div className="page-heading"><div><div className="eyebrow">{page==='GM Console'?'THE WORLD IS YOUR SANDBOX':'AZEROTHAI CONTROL PLANE'}</div><h1>{page==='Dashboard'?'Your realm, alive.':page}</h1><p className="subtitle">{({'Dashboard':'The people, personalities, and stories that make your world.','World Monitor':'Watch Azeroth breathe: population, activity, systems, and the lives unfolding right now.','Realm Director':'Shape the adventure around you. Let your characters bring it to life.','World & Housing':'Homes, routines, simulation bands, and believable population flow.','Bots':'Give every character a purpose, then let their story unfold.','Bot Recipes':'Same model. Different personalities. A world of possibilities.','Memory & Bonds':'A shared history makes the next encounter matter.','Event Stream':'Follow the decisions and changes happening across your realm.','GM Console':'Pull up a chair. Put on the blue robe. Run your world.','Server & Models':'Connect the game engine and the minds behind your characters.'} as any)[page]}</p></div><div className="actions">{page==='Bot Recipes'?<Button onClick={()=>{setRecipe(null);setRecipeOpen(true)}}><Plus size={16}/>Create recipe</Button>:<><Button variant="outline" disabled={busy} onClick={()=>void refresh()}><RefreshCw size={15}/>Refresh</Button><Button onClick={()=>setCreateOpen(true)}><Plus size={16}/>Create bot</Button></>}</div></div>
+ return <SidebarProvider style={{'--sidebar-width':'228px'} as React.CSSProperties}><Sidebar><SidebarHeader className="p-0"><div className="brand"><span className="brand-mark">A</span><div><strong>AzerothAI</strong><small>YOUR WORLD. ALIVE.</small></div></div></SidebarHeader><SidebarContent className="px-3"><div className="nav-section">REALM MANAGEMENT</div><SidebarMenu>{NAV.map(([name,Icon])=><SidebarMenuItem key={name}><SidebarMenuButton className="nav-button" isActive={page===name} onClick={()=>nav(name)}><Icon/><span>{name}</span></SidebarMenuButton></SidebarMenuItem>)}</SidebarMenu></SidebarContent><SidebarFooter><div className="sidebar-bottom"><Shield size={20} color="#d9b77a"/><p style={{marginTop:10,color:'#d6dfec'}}>{readOnly?'Realm visitor · Read only':'Realm administrator'}</p><small>{readOnly?'Live realm monitor':'Prototype 0.1 · Private realm'}</small><p style={{marginTop:20,fontFamily:'Georgia',fontStyle:'italic'}}>“What if Azeroth never felt empty?”</p></div></SidebarFooter></Sidebar><main className="app-main"><header className="topbar"><div className="crumb"><SidebarTrigger className="mobile-trigger"/>Living Realm <span>/</span> <span style={{color:'#d8e2f0'}}>{page}</span></div><div className="top-right"><span className="sim-badge">{capabilities.aleActiveRecently?'AZEROTHCORE LIVE':state?.settings.connector==='azerothcore'?'AzerothCore bridge':'SIMULATION REALM'}</span><span>{readOnly?'Visitor · Read only':'GM workspace'}</span></div></header><div className="content">
+ <div className="page-heading"><div><div className="eyebrow">{page==='GM Console'?'THE WORLD IS YOUR SANDBOX':'AZEROTHAI CONTROL PLANE'}</div><h1>{page==='Dashboard'?'Your realm, alive.':page}</h1><p className="subtitle">{({'Dashboard':'The people, personalities, and stories that make your world.','World Monitor':'Watch Azeroth breathe: population, activity, systems, and the lives unfolding right now.','Realm Director':'Shape the adventure around you. Let your characters bring it to life.','World & Housing':'Homes, routines, simulation bands, and believable population flow.','Bots':'Give every character a purpose, then let their story unfold.','Bot Recipes':'Same model. Different personalities. A world of possibilities.','Memory & Bonds':'A shared history makes the next encounter matter.','Event Stream':'Follow the decisions and changes happening across your realm.','GM Console':'Pull up a chair. Put on the blue robe. Run your world.','Server & Models':'Connect the game engine and the minds behind your characters.'} as any)[page]}</p></div><div className="actions">{readOnly?<Button variant="outline" onClick={()=>void refresh()}><RefreshCw size={15}/>Refresh</Button>:page==='Bot Recipes'?<Button onClick={()=>{setRecipe(null);setRecipeOpen(true)}}><Plus size={16}/>Create recipe</Button>:<><Button variant="outline" disabled={busy} onClick={()=>void refresh()}><RefreshCw size={15}/>Refresh</Button><Button onClick={()=>setCreateOpen(true)}><Plus size={16}/>Create bot</Button></>}</div></div>
  {error&&<div className="notice" role="alert">{error} <Button variant="outline" onClick={()=>void refresh()}>Retry</Button></div>}
  {!state?<div className="stats">{[1,2,3,4].map(n=><Skeleton key={n} className="h-32"/>)}</div>:<>
- {page==='Dashboard'&&<><div className="stats">{[[Users,'Active bots',state.bots.filter(b=>b.status==='online'&&(state.settings.connector==='simulation'||b.autonomy?.managed)).length,'Online in the simulation'],[BookOpen,'Bot recipes',state.recipes.length,'Distinct ways to experience the world'],[Brain,'Memories',state.bots.reduce((n,b)=>n+b.memories.length,0),'Stories carried into future decisions'],[Network,'Relationships',state.bots.reduce((n,b)=>n+b.relationships.length,0),'Directed bonds between characters']].map(([Icon,label,value,note]:any)=><div className="panel stat" key={label}><div className="stat-label">{label}<Icon/></div><div className="stat-value">{value}</div><small>{label==='Active bots'&&state.settings.connector!=='simulation'?'Acknowledged by the game bridge':note}</small></div>)}</div><section className="panel director-strip"><div className="director-content"><Compass className="director-icon"/><div><div className="eyebrow">YOUR NEXT ADVENTURE</div><h2>{state.director.experience}</h2><p>{state.director.zone} · {state.director.brief}</p></div></div><Button variant="outline" onClick={()=>nav('Realm Director')}>Shape the experience <ArrowRight size={15}/></Button></section><div className="dashboard-grid"><Panel title="Your characters" icon={Users} action={<Button variant="ghost" size="sm" onClick={()=>nav('Bots')}>Manage bots <ArrowRight size={14}/></Button>}>{botTable(state.bots.slice(0,5))}</Panel><Panel title="Realm pulse" icon={Radio}><div className="panel-body">{Array.from(new Set(state.bots.filter(b=>b.status==='online').map(b=>b.zone))).map(zone=>{const n=state.bots.filter(b=>b.status==='online'&&b.zone===zone).length;return <div className="zone-row" key={zone}><span className="zone-label">{zone}</span><span className="bar"><i style={{width:`${n/Math.max(1,state.bots.filter(b=>b.status==='online').length)*100}%`}}/></span><span>{n}</span></div>})}<p className="fineprint">Bot locations from the selected connector. Simulation locations are illustrative.</p><div className="engine-box" style={{marginTop:25,marginBottom:0}}><Brain size={23}/><div><h3>{state.settings.provider==='deterministic'?'Personality simulator':state.settings.model}</h3><p>{state.settings.provider==='deterministic'?'No model required. Try a decision from any online bot.':'Local model selected. Each decision includes identity and memories.'}</p></div></div></div></Panel><Panel title="Recent activity" icon={Activity} action={<Button variant="ghost" size="sm" onClick={()=>nav('Event Stream')}>View stream <ArrowRight size={14}/></Button>}>{<Events events={state.events.slice(-5)}/>}</Panel><Panel title="The Game Master’s chair" icon={Shield}><div className="panel-body"><p className="list-muted">Set the scene. Announce a gathering. Move a character to the next chapter of their story.</p><div className="gm-preview"><span>&lt;GM&gt; AzerothAI</span><p>Welcome to your world.</p><code>.announce An adventure awaits...</code></div><Button variant="outline" onClick={()=>nav('GM Console')}>Open GM console <Terminal size={15}/></Button></div></Panel></div></>}
+ {page==='Dashboard'&&<><div className="stats">{[[Users,'Active bots',state.bots.filter(b=>b.status==='online'&&(state.settings.connector==='simulation'||b.autonomy?.managed)).length,'Online in the simulation'],[BookOpen,'Bot recipes',state.recipes.length,'Distinct ways to experience the world'],[Brain,'Memories',state.bots.reduce((n,b)=>n+b.memories.length,0),'Stories carried into future decisions'],[Network,'Relationships',state.bots.reduce((n,b)=>n+b.relationships.length,0),'Directed bonds between characters']].map(([Icon,label,value,note]:any)=><div className="panel stat" key={label}><div className="stat-label">{label}<Icon/></div><div className="stat-value">{value}</div><small>{label==='Active bots'&&state.settings.connector!=='simulation'?'Acknowledged by the game bridge':note}</small></div>)}</div><section className="panel director-strip"><div className="director-content"><Compass className="director-icon"/><div><div className="eyebrow">YOUR NEXT ADVENTURE</div><h2>{state.director.experience}</h2><p>{state.director.zone} · {state.director.brief}</p></div></div><Button variant="outline" onClick={()=>nav('Realm Director')}>{readOnly?'View realm direction':'Shape the experience'} <ArrowRight size={15}/></Button></section><div className="dashboard-grid"><Panel title="Your characters" icon={Users} action={<Button variant="ghost" size="sm" onClick={()=>nav('Bots')}>{readOnly?'View bots':'Manage bots'} <ArrowRight size={14}/></Button>}>{botTable(state.bots.slice(0,5))}</Panel><Panel title="Realm pulse" icon={Radio}><div className="panel-body">{Array.from(new Set(state.bots.filter(b=>b.status==='online').map(b=>b.zone))).map(zone=>{const n=state.bots.filter(b=>b.status==='online'&&b.zone===zone).length;return <div className="zone-row" key={zone}><span className="zone-label">{zone}</span><span className="bar"><i style={{width:`${n/Math.max(1,state.bots.filter(b=>b.status==='online').length)*100}%`}}/></span><span>{n}</span></div>})}<p className="fineprint">Bot locations from the selected connector. Simulation locations are illustrative.</p><div className="engine-box" style={{marginTop:25,marginBottom:0}}><Brain size={23}/><div><h3>{state.settings.provider==='deterministic'?'Personality simulator':state.settings.model}</h3><p>{state.settings.provider==='deterministic'?'No model required. Try a decision from any online bot.':'Local model selected. Each decision includes identity and memories.'}</p></div></div></div></Panel><Panel title="Recent activity" icon={Activity} action={<Button variant="ghost" size="sm" onClick={()=>nav('Event Stream')}>View stream <ArrowRight size={14}/></Button>}>{<Events events={state.events.slice(-5)}/>}</Panel><Panel title="The Game Master’s chair" icon={Shield}><div className="panel-body"><p className="list-muted">Set the scene. Announce a gathering. Move a character to the next chapter of their story.</p><div className="gm-preview"><span>&lt;GM&gt; AzerothAI</span><p>Welcome to your world.</p><code>.announce An adventure awaits...</code></div><Button variant="outline" onClick={()=>nav('GM Console')}>Open GM console <Terminal size={15}/></Button></div></Panel></div></>}
  {page==='World Monitor'&&<WorldMonitor state={state} monitor={monitor} capabilities={capabilities} openBot={setBotId}/>}
  {page==='Bots'&&<><div className="toolbar"><Input aria-label="Search bots" placeholder="Search name, class, or location…" value={query} onChange={e=>setQuery(e.target.value)}/><Choice label="Bot status" value={filter} onChange={setFilter} items={options(['all','online','paused','offline','retired'])}/><small>{visible.length} characters</small></div><Panel title="Bot lifecycle" icon={Users}>{visible.length?botTable(visible):<div className="empty-note">No matching bots. Create a character or adjust your filters.</div>}</Panel></>}
- {page==='Bot Recipes'&&<><div className="notice">Recipes are versioned. Saving a recipe preserves existing bots’ personalities until you explicitly apply the new version.</div><div className="recipe-grid">{state.recipes.map((r,i)=><button key={r.id} className="panel recipe-card" onClick={()=>{setRecipe(r);setRecipeOpen(true)}}><div style={{display:'flex',justifyContent:'space-between'}}><span className="recipe-symbol">{i%2?<Compass size={23}/>:<BookOpen size={23}/>}</span><small>VERSION {r.version}</small></div><h3>{r.name}</h3><p>{r.description}</p><div className="tags">{r.tags.map(t=><span className="tag" key={t}>{t}</span>)}</div><div style={{display:'flex',justifyContent:'space-between',marginTop:21}}><small>{state.bots.filter(b=>b.recipeId===r.id).length} bot identities</small><small style={{color:'#9abef7'}}>Edit recipe →</small></div></button>)}</div></>}
- {page==='Realm Director'&&<Director state={state} act={act} busy={busy}/>}
+ {page==='Bot Recipes'&&<><div className="notice">Recipes are versioned. Saving a recipe preserves existing bots’ personalities until you explicitly apply the new version.</div><div className="recipe-grid">{state.recipes.map((r,i)=><button key={r.id} className="panel recipe-card" onClick={()=>{setRecipe(r);setRecipeOpen(true)}}><div style={{display:'flex',justifyContent:'space-between'}}><span className="recipe-symbol">{i%2?<Compass size={23}/>:<BookOpen size={23}/>}</span><small>VERSION {r.version}</small></div><h3>{r.name}</h3><p>{r.description}</p><div className="tags">{r.tags.map(t=><span className="tag" key={t}>{t}</span>)}</div><div style={{display:'flex',justifyContent:'space-between',marginTop:21}}><small>{state.bots.filter(b=>b.recipeId===r.id).length} bot identities</small><small style={{color:'#9abef7'}}>{readOnly?'View recipe →':'Edit recipe →'}</small></div></button>)}</div></>}
+ {page==='Realm Director'&&<fieldset disabled={readOnly} className="readonly-fieldset"><Director state={state} act={act} busy={busy||readOnly}/></fieldset>}
+ {page==='World & Housing'&&<fieldset disabled={readOnly} className="readonly-fieldset"><WorldHousing state={state} act={act} busy={busy||readOnly}/></fieldset>}
  {page==='Memory & Bonds'&&<div className="recipe-grid">{state.bots.map(b=><Panel key={b.id} title={b.name} icon={Heart} action={<Button variant="ghost" size="sm" onClick={()=>setBotId(b.id)}>Open profile</Button>}><div className="panel-body"><p className="list-muted">{b.memories.length} memories · {b.relationships.length} relationships</p><div className="memory"><p>{b.memories.at(-1)?.text??'No memories yet.'}</p></div>{b.relationships.map(r=><p className="list-muted" key={r.targetId}>{state.bots.find(x=>x.id===r.targetId)?.name} · {r.affinity>0?'+':''}{r.affinity} affinity<br/>{r.note}</p>)}</div></Panel>)}</div>}
- {page==='Social Life'&&<CommunityPanel state={state} act={act} busy={busy}/>}
- {page==='System Health'&&<OperationsPanel state={state} act={act} busy={busy}/>}
- {page==='Event Stream'&&<EventStream state={state}/>}
- {page==='Server & Models'&&<Settings state={state} act={act} busy={busy} capabilities={capabilities}/>}
- {page==='GM Console'&&<GM state={state} act={act} busy={busy} capabilities={capabilities} setConfirm={setConfirm}/>}
+ {page==='Social Life'&&<CommunityPanel state={state} act={act} busy={busy||readOnly}/>}
+ {page==='System Health'&&<OperationsPanel state={state} act={act} busy={busy||readOnly}/>}
+ {page==='Event Stream'&&<EventStream state={state} readOnly={readOnly}/>}
+ {page==='Server & Models'&&<fieldset disabled={readOnly} className="readonly-fieldset"><Settings state={state} act={act} busy={busy||readOnly} capabilities={capabilities}/></fieldset>}
+ {page==='GM Console'&&<fieldset disabled={readOnly} className="readonly-fieldset"><GM state={state} act={act} busy={busy||readOnly} capabilities={capabilities} setConfirm={setConfirm}/></fieldset>}
  </>}
  <p className="fineprint" style={{textAlign:'center',marginTop:28}}>AzerothAI shapes identity and intent. AzerothCore owns the rules of the world.</p></div></main>
  <Dialog open={createOpen} onOpenChange={setCreateOpen}><DialogContent className="sm:max-w-xl"><DialogHeader><DialogTitle>Create a character</DialogTitle><DialogDescription>Start with an identity and recipe. Spawn when you’re ready.</DialogDescription></DialogHeader>{state&&<CreateBot state={state} busy={busy} act={act} close={()=>setCreateOpen(false)}/>}</DialogContent></Dialog>
- <Dialog open={recipeOpen} onOpenChange={setRecipeOpen}><DialogContent className="sm:max-w-2xl max-h-[90vh] overflow-y-auto"><DialogHeader><DialogTitle>{recipe?'Edit bot recipe':'Create bot recipe'}</DialogTitle><DialogDescription>Traits guide high-level decisions. They never override game rules.</DialogDescription></DialogHeader><RecipeEditor key={recipe?.id??'new'} recipe={recipe} busy={busy} act={act} close={()=>setRecipeOpen(false)}/></DialogContent></Dialog>
- <Sheet open={!!selected} onOpenChange={o=>{if(!o)setBotId(null)}}><SheetContent className="w-full sm:max-w-xl overflow-y-auto p-6"><SheetHeader className="p-0"><SheetTitle>Bot profile</SheetTitle><SheetDescription>Identity, intent, and the story so far.</SheetDescription></SheetHeader>{selected&&state&&<BotProfile key={selected.id} bot={selected} state={state} busy={busy} act={act} perform={perform} confirm={setConfirm}/>}</SheetContent></Sheet>
+ <Dialog open={recipeOpen} onOpenChange={setRecipeOpen}><DialogContent className="sm:max-w-2xl max-h-[90vh] overflow-y-auto"><DialogHeader><DialogTitle>{readOnly?'Bot recipe':recipe?'Edit bot recipe':'Create bot recipe'}</DialogTitle><DialogDescription>Traits guide high-level decisions. They never override game rules.</DialogDescription></DialogHeader><fieldset disabled={readOnly} className="readonly-fieldset"><RecipeEditor key={recipe?.id??'new'} recipe={recipe} busy={busy} act={act} close={()=>setRecipeOpen(false)}/></fieldset></DialogContent></Dialog>
+ <Sheet open={!!selected} onOpenChange={o=>{if(!o)setBotId(null)}}><SheetContent className="w-full sm:max-w-xl overflow-y-auto p-6"><SheetHeader className="p-0"><SheetTitle>Bot profile</SheetTitle><SheetDescription>Identity, intent, and the story so far.</SheetDescription></SheetHeader>{selected&&state&&<BotProfile readOnly={readOnly} key={selected.id} bot={selected} state={state} busy={busy} act={act} perform={perform} confirm={setConfirm}/>}</SheetContent></Sheet>
  <AlertDialog open={!!confirm} onOpenChange={o=>{if(!o)setConfirm(null)}}><AlertDialogContent><AlertDialogHeader><AlertDialogTitle>{confirm?.title}</AlertDialogTitle><AlertDialogDescription>{confirm?.description}</AlertDialogDescription></AlertDialogHeader><AlertDialogFooter><AlertDialogCancel>Cancel</AlertDialogCancel><AlertDialogAction onClick={()=>{if(confirm)perform(confirm.action);setConfirm(null)}}>Confirm</AlertDialogAction></AlertDialogFooter></AlertDialogContent></AlertDialog><Toaster theme="dark" richColors position="bottom-right"/></SidebarProvider>;
 }
 function CreateBot({state,act,busy,close}:any){const [name,setName]=useState(''),[role,setRole]=useState('Priest'),[race,setRace]=useState('Human'),[recipeId,setRecipeId]=useState(state.recipes[0].id),[goal,setGoal]=useState(`Support ${state.director.experience.toLowerCase()} in ${state.director.zone}`);return <form onSubmit={async e=>{e.preventDefault();try{await act({type:'createBot',name,role,race,recipeId,goal});toast.success('Character created');close();}catch{}}}><div className="form-grid"><label className="field">Character name<Input required minLength={2} maxLength={24} value={name} onChange={e=>setName(e.target.value)} placeholder="A name worth remembering"/></label><label className="field">Class<Choice label="Class" value={role} onChange={setRole} items={options(['Priest','Warrior','Mage','Rogue','Hunter','Paladin','Warlock','Druid','Shaman'])}/></label><label className="field">Race<Choice label="Race" value={race} onChange={setRace} items={options(['Human','Night Elf','Dwarf','Orc','Undead','Tauren','Gnome','Troll','Blood Elf','Draenei'])}/></label><label className="field">Bot recipe<Choice label="Bot recipe" value={recipeId} onChange={setRecipeId} items={state.recipes.map((r:Recipe)=>({value:r.id,label:r.name}))}/></label><label className="field full">Personal goal<textarea required maxLength={200} value={goal} onChange={e=>setGoal(e.target.value)}/></label></div><p className="fineprint">The live game bridge validates race/class combinations when spawning.</p><div className="form-footer"><Button disabled={busy} type="submit">Create identity</Button></div></form>}
 function RecipeEditor({recipe,act,busy,close}:any){const [r,setR]=useState<Recipe>(recipe??{name:'',description:'',tags:['Curious'],sociability:50,aggression:20,curiosity:70,economy:30,activities:['explore','quest']});const [tags,setTags]=useState(r.tags.join(', '));return <form onSubmit={async e=>{e.preventDefault();try{await act({type:'saveRecipe',recipe:{...r,tags:tags.split(',').map(t=>t.trim()).filter(Boolean)}});toast.success('Recipe saved');close();}catch{}}}><div className="form-grid"><label className="field full">Recipe name<Input required minLength={2} maxLength={80} value={r.name} onChange={e=>setR({...r,name:e.target.value})}/></label><label className="field full">Personality description<textarea maxLength={500} value={r.description} onChange={e=>setR({...r,description:e.target.value})}/></label><label className="field full">Tags, separated by commas<Input value={tags} onChange={e=>setTags(e.target.value)}/></label></div><div className="section-grid" style={{gap:25,marginTop:20}}><div>{(['sociability','aggression','curiosity','economy'] as const).map(key=><div className="range-row" key={key}><div className="range-label"><span style={{textTransform:'capitalize'}}>{key}</span><span>{r[key]}</span></div><Slider aria-label={key} min={0} max={100} step={1} value={[r[key]]} onValueChange={v=>setR({...r,[key]:v[0]})}/></div>)}</div><div><h3 style={{margin:'15px 0'}}>Preferred activities</h3><div className="choices">{ACTIVITIES.map(a=><label className="choice-row" key={a}><Checkbox checked={r.activities.includes(a)} onCheckedChange={v=>setR({...r,activities:v?[...r.activities,a]:r.activities.filter(x=>x!==a)})}/>{a}</label>)}</div></div></div><div className="form-footer">{recipe&&<Button type="button" variant="outline" disabled={busy} onClick={async()=>{try{const {id,version,...copy}=r;void id;void version;await act({type:'saveRecipe',recipe:{...copy,name:`${copy.name} copy`.slice(0,80)}});close();}catch{}}}><Copy size={15}/>Duplicate</Button>}<Button disabled={busy||!r.activities.length}>Save recipe</Button></div></form>}
-function BotProfile({bot:b,state,act,busy,perform,confirm}:any){const [memory,setMemory]=useState(''),[importance,setImportance]=useState(7),[target,setTarget]=useState(state.bots.find((x:Bot)=>x.id!==b.id)?.id??''),[affinity,setAffinity]=useState(40),[note,setNote]=useState(''),[recipeId,setRecipeId]=useState(b.recipeId);const actions=b.status==='online'?['pause','despawn']:b.status==='paused'?['resume','despawn']:b.status==='offline'?['spawn','retire']:[];return <><div className="detail-header"><Avatar bot={b}/><div><h2>{b.name}</h2><p className="subtitle">Level {b.level} {b.race} {b.role}</p></div><span className={`tag ${b.status}`} style={{marginLeft:'auto'}}>{b.status}</span></div><div className="actions">{actions.map(a=><Button key={a} size="sm" variant={a==='spawn'?'default':'outline'} disabled={busy} onClick={()=>a==='retire'?confirm({title:`Retire ${b.name}?`,description:'The identity and memories remain in your realm, but this bot cannot spawn again in this prototype.',action:{type:'lifecycle',botId:b.id,action:a}}):perform({type:'lifecycle',botId:b.id,action:a})}>{a==='pause'?<Pause size={14}/>:a==='spawn'||a==='resume'?<Play size={14}/>:null}{a.charAt(0).toUpperCase()+a.slice(1)}</Button>)}<Button size="sm" disabled={busy||b.status!=='online'} onClick={()=>perform({type:'think',botId:b.id})}><Brain size={15}/>{busy?'Working…':'Run decision'}</Button></div><Tabs defaultValue="identity" className="mt-6"><TabsList className="w-full"><TabsTrigger value="identity">Identity</TabsTrigger><TabsTrigger value="memory">Memory</TabsTrigger><TabsTrigger value="bonds">Relationships</TabsTrigger></TabsList><TabsContent value="identity"><div className="detail-block"><h3>Current goal</h3><p>{b.goal}</p><p style={{marginTop:12,display:'flex',gap:7,alignItems:'center'}}><MapPin size={15}/>{b.zone}</p></div><div className="detail-block"><h3>{b.personality.name} <small>v{b.recipeVersion}</small></h3><p>{b.personality.description}</p><div className="actions" style={{marginTop:12}}>{b.personality.tags.map((t:string)=><span className="tag" key={t}>{t}</span>)}</div><div className="field" style={{marginTop:20}}><Choice label="Apply recipe" value={recipeId} onChange={setRecipeId} items={state.recipes.map((r:Recipe)=>({value:r.id,label:`${r.name} · v${r.version}`}))}/><Button variant="outline" disabled={busy} onClick={()=>perform({type:'applyRecipe',botId:b.id,recipeId})}>Apply current recipe version</Button></div></div><div className="detail-block"><h3>Latest decision</h3><p>{b.lastDecision?`${b.lastDecision.action}: ${b.lastDecision.reason}`:'No decisions yet. Run a decision while this bot is online.'}</p><small>{b.decisions} decisions acknowledged</small></div></TabsContent><TabsContent value="memory"><form className="detail-block" onSubmit={async e=>{e.preventDefault();try{await act({type:'memory',botId:b.id,text:memory,importance});setMemory('');}catch{}}}><label className="field">Add a memory<textarea required value={memory} maxLength={1000} onChange={e=>setMemory(e.target.value)} placeholder="What should this character remember?"/></label><div className="range-row"><div className="range-label">Importance <span>{importance}/10</span></div><Slider aria-label="Memory importance" min={1} max={10} value={[importance]} onValueChange={v=>setImportance(v[0])}/></div><Button disabled={busy}>Save memory</Button></form>{[...b.memories].reverse().map((m:any)=><div className="memory" key={m.id}><p className="list-muted">{m.text}</p><small>{m.source} · Importance {m.importance}/10 · {new Date(m.at).toLocaleDateString()}</small></div>)}</TabsContent><TabsContent value="bonds"><p className="fineprint">Bonds are directional. One character’s trust does not imply the other’s.</p><form className="detail-block" onSubmit={async e=>{e.preventDefault();try{await act({type:'relationship',botId:b.id,targetId:target,affinity,note});setNote('');}catch{}}}><div className="field"><label>Other character</label><Choice label="Other character" value={target} onChange={setTarget} items={state.bots.filter((x:Bot)=>x.id!==b.id).map((x:Bot)=>({value:x.id,label:x.name}))}/></div><div className="range-row"><div className="range-label">Affinity <span>{affinity>0?'+':''}{affinity}</span></div><Slider aria-label="Affinity" min={-100} max={100} value={[affinity]} onValueChange={v=>setAffinity(v[0])}/></div><label className="field">Why this bond exists<textarea required maxLength={300} value={note} onChange={e=>setNote(e.target.value)}/></label><Button className="mt-4" disabled={busy||!target}>Save relationship</Button></form>{b.relationships.map((r:any)=><div className="memory" key={r.targetId}><h3>{state.bots.find((x:Bot)=>x.id===r.targetId)?.name} <span className="tag">{r.affinity>0?'+':''}{r.affinity}</span></h3><p className="list-muted">{r.note}</p></div>)}</TabsContent></Tabs></>}
+function BotProfile({bot:b,state,act,busy,perform,confirm,readOnly=false}:any){const [memory,setMemory]=useState(''),[importance,setImportance]=useState(7),[target,setTarget]=useState(state.bots.find((x:Bot)=>x.id!==b.id)?.id??''),[affinity,setAffinity]=useState(40),[note,setNote]=useState(''),[recipeId,setRecipeId]=useState(b.recipeId);const actions=b.status==='online'?['pause','despawn']:b.status==='paused'?['resume','despawn']:b.status==='offline'?['spawn','retire']:[];return <><div className="detail-header"><Avatar bot={b}/><div><h2>{b.name}</h2><p className="subtitle">Level {b.level} {b.race} {b.role}</p></div><span className={`tag ${b.status}`} style={{marginLeft:'auto'}}>{b.status}</span></div><fieldset disabled={readOnly} className="readonly-fieldset"><div className="actions">{actions.map(a=><Button key={a} size="sm" variant={a==='spawn'?'default':'outline'} disabled={busy} onClick={()=>a==='retire'?confirm({title:`Retire ${b.name}?`,description:'The identity and memories remain in your realm, but this bot cannot spawn again in this prototype.',action:{type:'lifecycle',botId:b.id,action:a}}):perform({type:'lifecycle',botId:b.id,action:a})}>{a==='pause'?<Pause size={14}/>:a==='spawn'||a==='resume'?<Play size={14}/>:null}{a.charAt(0).toUpperCase()+a.slice(1)}</Button>)}<Button size="sm" disabled={busy||b.status!=='online'} onClick={()=>perform({type:'think',botId:b.id})}><Brain size={15}/>{busy?'Working…':'Run decision'}</Button></div></fieldset><Tabs defaultValue="identity" className="mt-6"><TabsList className="w-full"><TabsTrigger value="identity">Identity</TabsTrigger><TabsTrigger value="memory">Memory</TabsTrigger><TabsTrigger value="bonds">Relationships</TabsTrigger></TabsList><TabsContent value="identity"><div className="detail-block"><h3>Current goal</h3><p>{b.goal}</p><p style={{marginTop:12,display:'flex',gap:7,alignItems:'center'}}><MapPin size={15}/>{b.zone}</p></div><div className="detail-block"><h3>{b.personality.name} <small>v{b.recipeVersion}</small></h3><p>{b.personality.description}</p><div className="actions" style={{marginTop:12}}>{b.personality.tags.map((t:string)=><span className="tag" key={t}>{t}</span>)}</div><fieldset disabled={readOnly} className="field" style={{marginTop:20}}><Choice label="Apply recipe" value={recipeId} onChange={setRecipeId} items={state.recipes.map((r:Recipe)=>({value:r.id,label:`${r.name} · v${r.version}`}))}/><Button variant="outline" disabled={busy} onClick={()=>perform({type:'applyRecipe',botId:b.id,recipeId})}>Apply current recipe version</Button></fieldset></div><div className="detail-block"><h3>Latest decision</h3><p>{b.lastDecision?`${b.lastDecision.action}: ${b.lastDecision.reason}`:'No decisions yet. Run a decision while this bot is online.'}</p><small>{b.decisions} decisions acknowledged</small></div></TabsContent><TabsContent value="memory"><fieldset disabled={readOnly} className="readonly-fieldset"><form className="detail-block" onSubmit={async e=>{e.preventDefault();try{await act({type:'memory',botId:b.id,text:memory,importance});setMemory('');}catch{}}}><label className="field">Add a memory<textarea required value={memory} maxLength={1000} onChange={e=>setMemory(e.target.value)} placeholder="What should this character remember?"/></label><div className="range-row"><div className="range-label">Importance <span>{importance}/10</span></div><Slider aria-label="Memory importance" min={1} max={10} value={[importance]} onValueChange={v=>setImportance(v[0])}/></div><Button disabled={busy}>Save memory</Button></form></fieldset>{[...b.memories].reverse().map((m:any)=><div className="memory" key={m.id}><p className="list-muted">{m.text}</p><small>{m.source} · Importance {m.importance}/10 · {new Date(m.at).toLocaleDateString()}</small></div>)}</TabsContent><TabsContent value="bonds"><p className="fineprint">Bonds are directional. One character’s trust does not imply the other’s.</p><fieldset disabled={readOnly} className="readonly-fieldset"><form className="detail-block" onSubmit={async e=>{e.preventDefault();try{await act({type:'relationship',botId:b.id,targetId:target,affinity,note});setNote('');}catch{}}}><div className="field"><label>Other character</label><Choice label="Other character" value={target} onChange={setTarget} items={state.bots.filter((x:Bot)=>x.id!==b.id).map((x:Bot)=>({value:x.id,label:x.name}))}/></div><div className="range-row"><div className="range-label">Affinity <span>{affinity>0?'+':''}{affinity}</span></div><Slider aria-label="Affinity" min={-100} max={100} value={[affinity]} onValueChange={v=>setAffinity(v[0])}/></div><label className="field">Why this bond exists<textarea required maxLength={300} value={note} onChange={e=>setNote(e.target.value)}/></label><Button className="mt-4" disabled={busy||!target}>Save relationship</Button></form></fieldset>{b.relationships.map((r:any)=><div className="memory" key={r.targetId}><h3>{state.bots.find((x:Bot)=>x.id===r.targetId)?.name} <span className="tag">{r.affinity>0?'+':''}{r.affinity}</span></h3><p className="list-muted">{r.note}</p></div>)}</TabsContent></Tabs></>}
 function WorldMonitor({state,monitor,capabilities,openBot}:any){
  const living:Bot[]=state.bots.filter((b:Bot)=>b.status!=='dead'&&b.status!=='retired');
  const active=living.filter((b:Bot)=>b.status==='online');
@@ -132,7 +133,7 @@ function WorldHousing({state,act,busy}:any){
  return <><div className="stats">{[[House,'Homes',state.homes.length,'Persistent places residents return to'],[Users,'Foreground',foreground,`Max ${state.settings.population.foregroundMax}`],[Activity,'Background',background,`Max ${state.settings.population.backgroundMax}`],[Pause,'Dormant',dormant,'Sleeping or cheaply simulated']].map(([Icon,label,value,note]:any)=><div className="panel stat" key={label}><div className="stat-label">{label}<Icon/></div><div className="stat-value">{value}</div><small>{note}</small></div>)}</div><div className="section-grid"><Panel title="World Population Director" icon={Compass}><form className="panel-body" onSubmit={async e=>{e.preventDefault();try{await act({type:'worldTrigger',kind,zone,playerName,detail});toast.success('World trigger evaluated');}catch{}}}><div className="form-grid"><label className="field">Trigger<Choice label="World trigger" value={kind} onChange={setKind} items={options(['zone-change','interaction','time','manual'])}/></label><label className="field">Zone<Input required value={zone} onChange={e=>setZone(e.target.value)}/></label><label className="field">Player name<Input value={playerName} onChange={e=>setPlayerName(e.target.value)}/></label><label className="field full">Context<textarea maxLength={500} value={detail} onChange={e=>setDetail(e.target.value)} placeholder="What happened in the world?"/></label></div><div className="form-footer"><Button disabled={busy}><Sparkles size={16}/>Evaluate population</Button></div><p className="fineprint">AzerothAI prefers existing residents with a believable reason to be here. It does not create disposable identities to fill a zone.</p></form></Panel><Panel title="Latest population plan" icon={Activity}><div className="panel-body">{plan?<><div className="health-row"><span>Trigger</span><strong>{plan.trigger.kind} · {plan.trigger.zone}</strong></div><div className="health-row"><span>Zone target</span><strong>{plan.target}</strong></div><div className="health-row"><span>Already active</span><strong>{plan.activeBefore}</strong></div><div className="health-row"><span>Requested</span><strong>{plan.requested}</strong></div><div className="health-row"><span>Capacity available</span><strong>{plan.capacity}</strong></div><div className="health-row"><span>Residents selected</span><strong>{plan.selectedBotIds.length}</strong></div>{plan.selectedBotIds.length>0&&<p className="list-muted" style={{marginTop:16}}>{plan.selectedBotIds.map((id:string)=>state.bots.find((b:Bot)=>b.id===id)?.name).filter(Boolean).join(', ')}</p>}{plan.rejectedReasons.map((x:string)=><p className="fineprint" key={x}>{x}</p>)}</>:<div className="empty-note">No population trigger has been evaluated yet.</div>}</div></Panel></div><Panel title="Housing registry" icon={House} className="mt-5"><Table className="data-table"><TableHeader><TableRow><TableHead>Home</TableHead><TableHead>Zone</TableHead><TableHead>Type</TableHead><TableHead>Residents</TableHead><TableHead>Safety</TableHead></TableRow></TableHeader><TableBody>{state.homes.map((h:any)=><TableRow key={h.id}><TableCell><strong>{h.name}</strong><small style={{display:'block'}}>{h.description}</small></TableCell><TableCell>{h.zone}</TableCell><TableCell>{h.type}</TableCell><TableCell>{h.residentIds.map((id:string)=>state.bots.find((b:Bot)=>b.id===id)?.name).filter(Boolean).join(', ')||'Vacant'} <small>({h.residentIds.length}/{h.capacity})</small></TableCell><TableCell>{h.safety}/100</TableCell></TableRow>)}</TableBody></Table></Panel></>
 }
 function Director({state,act,busy}:any){const [d,setD]=useState(state.director);return <div className="section-grid"><Panel title="Set the scene" icon={Compass}><form className="panel-body" onSubmit={async e=>{e.preventDefault();try{await act({type:'director',...d});toast.success('Direction saved and bot goals updated');}catch{}}}><div className="form-grid"><label className="field full">What kind of session do you want?<Choice label="Experience" value={d.experience} onChange={experience=>setD({...d,experience})} items={options(['Adventuring companions','A lively town','Exploration and discovery','Rivalries and tension'])}/></label><label className="field">Your character name<Input value={d.playerName} maxLength={40} onChange={e=>setD({...d,playerName:e.target.value})} placeholder="Optional"/></label><label className="field">Focus zone<Input required value={d.zone} maxLength={100} onChange={e=>setD({...d,zone:e.target.value})}/></label><label className="field full">Your direction<textarea required maxLength={500} value={d.brief} onChange={e=>setD({...d,brief:e.target.value})} style={{minHeight:140}}/></label></div><div className="form-footer"><Button disabled={busy}><Sparkles size={16}/>Apply realm direction</Button></div><p className="fineprint">Updates the goals of all non-retired bots. Run individual decisions from a bot profile to act on this direction.</p></form></Panel><Panel title="You play. The world responds." icon={Shield}><div className="panel-body"><div className="engine-box"><Users size={24}/><div><h3>Characters, not background noise</h3><p>A healer who remembers you. A trader with an agenda. A familiar rival on the road.</p></div></div><div className="engine-box"><Compass size={24}/><div><h3>Direction, not a scripted outcome</h3><p>Your brief goes into bot goals. Personality, memory, and available actions influence their next choice.</p></div></div><div className="engine-box"><Shield size={24}/><div><h3>The game stays the game</h3><p>The game connector translates intent. AzerothCore resolves movement, combat, loot, and progression.</p></div></div><div className="notice">Live Playerbots continue playing under AzerothCore even with no human online. AzerothAI periodically adds personality-, memory-, and goal-driven high-level intentions for authoritatively observed residents.</div></div></Panel></div>}
-function EventStream({state}:any){const [events,setEvents]=useState<RealmEvent[]>(state.events),[paused,setPaused]=useState(false),[kind,setKind]=useState('all'),[connection,setConnection]=useState('Connecting');useEffect(()=>{if(paused){setConnection('Paused');return;}setEvents(state.events);const source=new EventSource(`/api/events?after=${state.sequence}`);source.addEventListener('realm',(e:MessageEvent)=>{const event=JSON.parse(e.data);setEvents(old=>old.some(x=>x.id===event.id)?old:[...old,event].slice(-500));setConnection('Connected');});source.addEventListener('gap',()=>void fetch('/api/state').then(r=>r.json()).then((s:any)=>setEvents(s.events)));source.onopen=()=>setConnection('Connected');source.onerror=()=>setConnection('Reconnecting');return()=>source.close();},[paused]);return <><div className="toolbar"><Choice label="Event category" value={kind} onChange={setKind} items={options(['all','system','lifecycle','decision','memory','relationship','recipe','gm','death','housing','population','error'])}/><Button variant="outline" onClick={()=>setPaused(!paused)}>{paused?<Play size={15}/>:<Pause size={15}/>} {paused?'Resume stream':'Pause stream'}</Button><small>{connection}</small></div><Panel title="Realm event stream" icon={Activity} action={<small>Latest 500 events · replay on reconnect</small>}><Events events={events.filter(e=>kind==='all'||e.kind===kind)}/></Panel></>}
+function EventStream({state,readOnly=false}:any){const [events,setEvents]=useState<RealmEvent[]>(state.events),[paused,setPaused]=useState(false),[kind,setKind]=useState('all'),[connection,setConnection]=useState('Connecting');useEffect(()=>{if(paused){setConnection('Paused');return;}setEvents(state.events);if(readOnly){setConnection('Live · read only');return;}const source=new EventSource(`/api/events?after=${state.sequence}`);source.addEventListener('realm',(e:MessageEvent)=>{const event=JSON.parse(e.data);setEvents(old=>old.some(x=>x.id===event.id)?old:[...old,event].slice(-500));setConnection('Connected');});source.addEventListener('gap',()=>void fetch('/api/state').then(r=>r.json()).then((s:any)=>setEvents(s.events)));source.onopen=()=>setConnection('Connected');source.onerror=()=>setConnection('Reconnecting');return()=>source.close();},[paused,readOnly,state.sequence]);return <><div className="toolbar"><Choice label="Event category" value={kind} onChange={setKind} items={options(['all','system','lifecycle','decision','memory','relationship','recipe','gm','death','housing','population','error'])}/><Button variant="outline" onClick={()=>setPaused(!paused)}>{paused?<Play size={15}/>:<Pause size={15}/>} {paused?'Resume stream':'Pause stream'}</Button><small>{connection}</small></div><Panel title="Realm event stream" icon={Activity} action={<small>Latest 500 events · replay on reconnect</small>}><Events events={events.filter(e=>kind==='all'||e.kind===kind)}/></Panel></>}
 function Settings({state,act,busy,capabilities}:any){
  const [s,setS]=useState(state.settings),[health,setHealth]=useState('');
  const brains=s.brains;
diff --git a/app/visitor/page.tsx b/app/visitor/page.tsx
new file mode 100644
index 0000000..d4b9a27
--- /dev/null
+++ b/app/visitor/page.tsx
@@ -0,0 +1,3 @@
+'use client';
+import Home from '../page';
+export default function Visitor(){return <Home readOnly/>;}
diff --git a/docs/spectator-monitor.md b/docs/spectator-monitor.md
index 00a817e..0a98ed7 100644
--- a/docs/spectator-monitor.md
+++ b/docs/spectator-monitor.md
@@ -11,8 +11,8 @@ observed bot parties; guild goals and progress; confirmed social activity.
 Only autonomous bot-to-bot reply transcripts are public. Human conversations,
 whispers, memories, account/character IDs, tokens, configuration and PC telemetry
 are excluded. All text is rendered with textContent, never HTML interpolation.
-The HTTP service allows only explicit static paths and `/api/realm`, `/health`,
-`/robots.txt`. Mutation methods return 405; admin paths return 404.
+The HTTP service allows explicit public assets and read-only projections described
+below. Mutation methods return 405; administrative command paths return 404.
 
 ## Install and publish
 
@@ -58,3 +58,24 @@ After changing spectator source or assets, restart its service:
 ```sh
 systemctl --user restart azerothai-spectator
 ```
+
+## Shared dashboard (visitor edition)
+
+The public root now serves the application's `/visitor` route, which uses the
+same React dashboard and CSS as the administrator. Navigation, filters, profiles,
+recipe details and the world monitor remain usable. Editing forms and GM inputs
+are disabled; the action dispatcher also refuses writes in visitor mode.
+The public server independently rejects every mutation method, including server
+actions, and never proxies a viewer-selected backend route or request headers.
+
+`/api/state` is an explicit public projection shaped for the shared UI. Bot memory
+views contain confirmed shared social history, not private player conversations
+or operator-injected memories. The event stream is a polling view of that public
+history. `/api/health`, `/api/world-monitor` and `/api/operations` return selected
+read-only indicators. Native account identifiers, raw command queues, credentials,
+endpoint URLs and private maintenance logs are omitted. Built JavaScript/CSS/font
+assets are served from `dist/client` with traversal and source-map requests denied.
+
+Build with `pnpm build` before restarting `azerothai-runtime` and
+`azerothai-spectator`. The existing Funnel address and private admin address stay
+separate. No cache actions are added.
diff --git a/scripts/spectator-server.py b/scripts/spectator-server.py
index 7fbd4fc..8f7d8ac 100644
--- a/scripts/spectator-server.py
+++ b/scripts/spectator-server.py
@@ -64,6 +64,58 @@ def project(state):
             'parties': list(parties.values()), 'guilds': guilds, 'feed': feed[-60:][::-1]}
 
 
+def public_state(state):
+    """Admin-shaped data for the shared read-only UI, with an explicit allowlist."""
+    def pick(obj, keys):
+        return {k: obj[k] for k in keys.split() if k in obj and isinstance(obj[k], (str, int, float, bool))}
+    def recipe(r):
+        return {**pick(r, 'id name description sociability aggression curiosity economy version'),
+                'tags': [text(t, 80) for t in r.get('tags', [])],
+                'activities': [a for a in r.get('activities', []) if a in ['quest','explore','trade','rest','socialize']]}
+    projected = project(state)
+    feed = [{**e, 'id': 'public-'+str(i), 'status': 'confirmed'} for i, e in enumerate(reversed(projected['feed']))]
+    bots = []
+    for b in state.get('bots', []):
+        if not b.get('autonomy', {}).get('managed'):
+            continue
+        bot = pick(b, 'id name role race level zone status tier mortal plotArmorHpFloor simulationBand homeId recipeId recipeVersion goal decisions')
+        bot['personality'] = recipe(b.get('personality', {}))
+        bot['routine'] = {**pick(b.get('routine', {}), 'wakeHour sleepHour'), 'preferredZones': b.get('routine', {}).get('preferredZones', [])}
+        bot['autonomy'] = {'managed': True, **pick(b.get('autonomy', {}), 'observedAt lastIntentAt nextIntentAt')}
+        world = b.get('world') or {}
+        bot['world'] = {**pick(world, 'at team guildId guildName guildRank groupId inCombat x y mapId stationarySince'),
+                        'groupNames': [n for n in world.get('groupNames', []) if any(x['name']==n for x in state['bots'] if x.get('autonomy',{}).get('managed'))], 'nearby': []}
+        bot['relationships'] = [pick(r, 'targetId affinity note') for r in b.get('relationships', [])]
+        # Show shared history, never personal whispers or operator-injected memories.
+        bot['memories'] = [{'id': e['id'], 'text': e['text'], 'at': e['at'], 'source': 'observation', 'importance': 5}
+                           for e in feed if b['name'] in e['names']]
+        if b.get('death'):
+            bot['death'] = pick(b['death'], 'id at zone level cause killer source verified')
+        if b.get('lastDecision'):
+            bot['lastDecision'] = {'action': b['lastDecision']['action'], 'reason': 'Following the resident’s current activity.', 'goal': bot.get('goal','')}
+        bots.append(bot)
+    settings = state.get('settings') or {}
+    return {'revision': state.get('revision',0), 'sequence': state.get('sequence',0), 'aleRosterAt': state.get('aleRosterAt',0),
+            'bots': bots, 'recipes': [recipe(r) for r in state.get('recipes',[])],
+            'homes': [{**pick(h,'id name zone type capacity storageSlots safety description'), 'ownerIds':h.get('ownerIds',[]), 'residentIds':h.get('residentIds',[])} for h in state.get('homes',[])],
+            'events': [{'id':e['id'],'seq':i,'at':e['at'],'kind':'relationship' if e['kind']=='relationship' else 'lifecycle','message':e['text'],'mode':'azerothcore'} for i,e in enumerate(feed)],
+            'settings': {**pick(settings,'connector provider model'),
+                         'brains':pick(settings.get('brains',{}),'enabled residentModel heroModel backgroundUseLLM residentMemoryLimit heroMemoryLimit residentMaxTokens heroMaxTokens'),
+                         'hardcore':pick(settings.get('hardcore',{}),'enabled requireVerifiedDeath memorialize'),
+                         'population':pick(settings.get('population',{}),'defaultZoneTarget zoneMax serverMax foregroundMax backgroundMax')},
+            'director':{**pick(state.get('director',{}),'experience zone brief'),'playerName':''}, 'population':{}, 'operations':{},
+            'opsRetentionDays':state.get('opsRetentionDays',7),
+            'community':{'feed':feed,'evidence':[],'guilds':[{**g,'id':i} for i,g in enumerate(projected['guilds'])],
+                         'partiesEnabled':state.get('community',{}).get('partiesEnabled',True),
+                         'guildsEnabled':state.get('community',{}).get('guildsEnabled',True)}}
+
+
+def local_get(path):
+    opener = urllib.request.build_opener(NoRedirect(), urllib.request.ProxyHandler({}))
+    with opener.open('http://127.0.0.1:8787'+path, timeout=10) as response:
+        return response.read(8 * 1024 * 1024)
+
+
 class Snapshot:
     def __init__(self):
         self.lock = threading.Lock()
@@ -81,7 +133,8 @@ class Snapshot:
                         raw = response.read(8 * 1024 * 1024 + 1)
                         if len(raw) > 8 * 1024 * 1024:
                             raise ValueError('State too large')
-                        self.data = project(json.loads(raw))
+                        state = json.loads(raw)
+                        self.data = {**project(state), "state": public_state(state)}
                     self.failed = False
                 except Exception:
                     self.failed = True
@@ -119,14 +172,46 @@ class Handler(BaseHTTPRequestHandler):
         self.send_header('X-Frame-Options', 'DENY')
         self.send_header('Referrer-Policy', 'no-referrer')
         self.send_header('X-Robots-Tag', 'noindex, nofollow')
-        self.send_header('Content-Security-Policy', "default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; img-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'")
+        self.send_header('Content-Security-Policy', "default-src 'none'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; connect-src 'self'; img-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'")
         self.end_headers()
         if self.command != 'HEAD':
             self.wfile.write(body)
 
     def do_GET(self):
         path = self.path.split('?', 1)[0]
-        if path in ASSETS:
+        if path in ('/', '/visitor', '/visitor/'):
+            try:
+                self.reply(200, local_get('/visitor'), 'text/html; charset=utf-8')
+            except Exception:
+                self.reply(503, b'{"error":"Realm temporarily unavailable"}')
+        elif path == '/api/state':
+            data = SNAPSHOT.get()
+            self.reply(200 if data else 503, json.dumps(data['state'] if data else {'error':'Realm unavailable'}).encode())
+        elif path == '/api/health':
+            data = SNAPSHOT.get()
+            self.reply(200, json.dumps({'ok':bool(data),'aleConfigured':True,'aleActiveRecently':bool(data and not data['stale']), 'llmConfigured':bool(data and data['state']['settings'].get('provider')!='deterministic')}).encode())
+        elif path == '/api/world-monitor':
+            data = SNAPSHOT.get()
+            at = data['rosterAt'] if data else 0
+            from datetime import datetime, timezone
+            self.reply(200, json.dumps({'ok':bool(data),'ale':{'lastEventAt':datetime.fromtimestamp(at,timezone.utc).isoformat() if at else None,'activeRecently':bool(data and not data['stale'])},'events':[],'commands':{}}).encode())
+        elif path == '/api/operations':
+            try:
+                health = json.loads(local_get('/api/operations'))
+                samples = [{k:v for k,v in row.items() if k in ('host','at','cpuPercent','memoryTotalMB','memoryAvailableMB','diskFreeGB','databaseMB','logsMB','modelAvailable','runtimeService')} for row in health.get('samples',[])]
+                self.reply(200, json.dumps({'samples':samples,'stuck':[{k:v for k,v in row.items() if k in ('name','zone','minutes')} for row in health.get('stuck',[])]}).encode())
+            except Exception:
+                self.reply(503,b'{"error":"Health data unavailable"}')
+        elif path.startswith(('/assets/', '/_vinext/', '/_next/')):
+            # Built public assets only. No source maps, dotfiles or traversal.
+            import mimetypes
+            root = ROOT.parent / 'dist/client'
+            asset = (root / path.lstrip('/')).resolve()
+            if '%' in path or '..' in path or not asset.is_relative_to(root.resolve()) or asset.suffix not in ('.js','.css','.woff','.woff2','.png','.svg','.ico') or not asset.is_file():
+                self.reply(404,b'{"error":"Not found"}')
+            else:
+                self.reply(200,asset.read_bytes(),mimetypes.guess_type(str(asset))[0] or 'application/octet-stream')
+        elif path in ASSETS:
             filename, content_type = ASSETS[path]
             self.reply(200, (ROOT / filename).read_bytes(), content_type)
         elif path == '/api/realm':
diff --git a/scripts/test-spectator.py b/scripts/test-spectator.py
index 6878938..e3aff8f 100644
--- a/scripts/test-spectator.py
+++ b/scripts/test-spectator.py
@@ -3,6 +3,7 @@ import importlib.util
 import json
 import threading
 import unittest
+from unittest.mock import patch
 import urllib.error
 import urllib.request
 from pathlib import Path
@@ -22,7 +23,11 @@ class SpectatorTests(unittest.TestCase):
                                    ('social-1', ['A', 'B'], 'SYNTHETIC_PROMPT'),
                                    ('social-1:reply', ['A', 'B'], 'Hello friend'),
                                    ('social-2:reply', ['HumanPlayer', 'A'], 'NOT_BOT_CHAT')]]
-        projected = m.project({'bots': bots, 'settings': {'token': 'SECRET'}, 'community': {'feed': feed}})
+        source={'bots': bots, 'settings': {'token': 'SECRET'}, 'community': {'feed': feed}}
+        projected = m.project(source)
+        public = m.public_state(source)
+        for forbidden in ['PRIVATE_MEMORY','PRIVATE_WHISPER','SYNTHETIC_PROMPT','NOT_BOT_CHAT','SECRET','accountId']:
+            self.assertNotIn(forbidden,json.dumps(public))
         serialized = json.dumps(projected)
         for private in ['PRIVATE_MEMORY', 'PRIVATE_WHISPER', 'SYNTHETIC_PROMPT', 'NOT_BOT_CHAT', 'HumanPlayer', 'SECRET', 'accountId', 'internal-guid']:
             self.assertNotIn(private, serialized)
@@ -35,18 +40,27 @@ class SpectatorTests(unittest.TestCase):
         worker.start()
         base = 'http://127.0.0.1:' + str(server.server_port)
         try:
-            for route in ['/', '/app.js', '/style.css', '/health']:
+            for route in ['/app.js', '/style.css', '/health']:
                 with urllib.request.urlopen(base + route) as response:
                     self.assertEqual(response.status, 200)
                     self.assertIn("default-src 'none'", response.headers['Content-Security-Policy'])
-            for path in ['/api/state', '/api/actions', '/api/ale/operator', '/api/operations', '/.dev.vars', '/../.dev.vars', '/%2e%2e/.dev.vars', '//api/state']:
+            for path in ['/api/actions', '/api/ale/operator', '/.dev.vars', '/../.dev.vars', '/%2e%2e/.dev.vars', '/api/bridge/ale/poll', '/assets/../../.dev.vars', '/assets/private.map']:
                 with self.assertRaises(urllib.error.HTTPError) as error:
                     urllib.request.urlopen(base + path)
                 self.assertEqual(error.exception.code, 404)
+                error.exception.close()
+            with patch.object(m,'local_get',return_value=b'<html>Visitor</html>') as upstream:
+                with urllib.request.urlopen(base+'/') as response:
+                    self.assertEqual(response.read(),b'<html>Visitor</html>')
+                upstream.assert_called_once_with('/visitor')
+            with patch.object(m.SNAPSHOT,'get',return_value={'state':{'bots':[]}}):
+                with urllib.request.urlopen(base+'/api/state') as response:
+                    self.assertEqual(json.load(response),{'bots':[]})
             for method in ['POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'TRACE']:
                 with self.assertRaises(urllib.error.HTTPError) as error:
                     urllib.request.urlopen(urllib.request.Request(base + '/api/actions', method=method, data=b'{}'))
                 self.assertEqual(error.exception.code, 405)
+                error.exception.close()
         finally:
             server.shutdown()
             server.server_close()