@theihtisham/agent-shadow-brain 7.2.0 → 7.22.0

package/dist/dashboard/brain-hub-client.js

@@ -0,0 +1,435 @@
+export const BRAIN_HUB_CLIENT = String.raw `
+const $ = id => document.getElementById(id);
+const arr = value => Array.isArray(value) ? value : [];
+const esc = value => String(value ?? '').replace(/[&<>"']/g, char => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[char]));
+const fmt = value => Number.isFinite(value) ? value.toLocaleString() : 'Unavailable';
+const clock = new Intl.DateTimeFormat(undefined,{hour:'2-digit',minute:'2-digit',second:'2-digit'});
+const time = value => value && Number.isFinite(new Date(value).getTime()) ? clock.format(new Date(value)) : '—';
+const isoTime = value => value && Number.isFinite(new Date(value).getTime()) ? new Date(value).toLocaleString() : 'Unavailable';
+const reduced = matchMedia('(prefers-reduced-motion: reduce)');
+const local = document.documentElement.dataset.projectLocal === 'true';
+const projectFeatureLimits={crossProjectContext:'Project memory stays scoped to this project.',automaticBriefing:'Automatic briefing requires a legacy analysis session.'};
+const featureLimit = id => local ? projectFeatureLimits[id] : id==='projectFileActivity'?'Open a project workspace to observe project files.':undefined;
+const nav = {overview:'Brain overview',sessions:'Sessions',knowledge:'Knowledge',room:'Collaboration',context:'Context',models:'Models',usage:'Usage',learning:'Learning',setup:'Setup'};
+const labels = {codex:'Codex','claude-code':'Claude Code',opencode:'OpenCode','deepseek-harness':'DeepSeek Harness',user:'Operator'};
+const hostName = value => labels[value] ?? value ?? 'Unknown host';
+const state = {view:'overview',project:'',overview:null,server:null,connection:'connecting',errors:{},graph:null,features:null,integrations:null,
+  nativeConnection:null,nativeThreads:null,nativeThread:null,nativeArchived:false,nativeListCursor:null,nativeThreadCursor:null,sessions:null,session:null,sessionBefore:null,sessionCheckpoint:null,usage:null,sources:null,source:null,evidence:null,teachDraft:'',profile:null,feedback:null,hub:null,documents:null,docPage:1,room:null,context:null,contextInput:null,comparison:null,skill:null,skillInput:null,
+  picked:null,memory:null,focus:false,inspector:'record',graphMode:'graph',listing:false,events:[],cursor:undefined,journalId:undefined,
+  live:false,recording:false,journalGap:false,replayId:null,replayExpired:false,motionPaused:false,motionStarted:0,pulseIds:[],pending:false,message:'',messageError:false,
+  dataEpoch:0,viewEpoch:0,graphEpoch:0,graphFilter:'all',search:null,lessonFrom:null,policy:null,policySelection:null,managedSkills:null,managedSkillPlan:null,presence:null};
+let timer, polling=false, pollAgain=false, failures=0, polls=0;
+let controller;
+const list = (content,attributes='',classes='') => '<ul class="list '+classes+'" '+attributes+'>'+content+'</ul>';
+const chip = (text,tone='') => '<span class="chip '+tone+'">'+esc(text)+'</span>';
+const btn = (text, attrs='', kind='') => '<button type="button" class="btn '+kind+'" '+attrs+'>'+esc(text)+'</button>';
+const submit = (text, kind='primary') => '<button type="submit" class="btn '+kind+'" '+(state.pending?'disabled':'')+'>'+esc(text)+'</button>';
+const panel = (title, content, meta='', cls='') => '<section class="panel '+cls+'"><div class="panel-head"><h2>'+esc(title)+'</h2>'+meta+'</div>'+content+'</section>';
+const heading = (title, body, actions='') => '<div class="page-head"><div><h1 id="title" tabindex="-1">'+esc(title)+'</h1><p class="small muted">'+esc(body)+'</p></div><div class="actions">'+actions+'</div></div>';
+const empty = (title, detail, action='') => '<div class="empty"><strong>'+esc(title)+'</strong><p class="small">'+esc(detail)+'</p>'+(action?'<div class="actions">'+action+'</div>':'')+'</div>';
+const fact = (label,value) => '<div><dt>'+esc(label)+'</dt><dd>'+esc(value ?? 'Unavailable')+'</dd></div>';
+const error = (key, fallback) => state.errors[key] ? empty('Could not load '+fallback,state.errors[key],btn('Retry','data-action="refresh"')) : '';
+const action = (id,text,kind='',extra='') => btn(text,'data-action="'+id+'" '+extra,kind);
+const view = (id,text=nav[id]) => btn(text,'data-view="'+id+'"','quiet');
+const json = body => ({method:'POST',body:JSON.stringify(body),headers:{'Content-Type':'application/json'}});
+const retryKeys=new Map();
+async function hubWrite(route,input){
+  const id=route+'\n'+JSON.stringify(input);
+  if(!retryKeys.has(id)){
+    if(retryKeys.size>=40)retryKeys.delete(retryKeys.keys().next().value);
+    retryKeys.set(id,crypto.randomUUID());
+  }
+  try{
+    const result=await api(route,json({...input,key:retryKeys.get(id)}));
+    retryKeys.delete(id);return result;
+  }catch(failure){
+    if(failure.status&&failure.status<500)retryKeys.delete(id);
+    throw failure;
+  }
+}
+function status(message='',isError=false){
+  state.message=message;state.messageError=isError;
+  const target=$('view-status');
+  if(target){target.textContent=message;target.dataset.error=String(isError);}
+}
+function projectQuery(extra={}){
+  return '?'+new URLSearchParams({...extra,...(state.project?{project:state.project}:{})});
+}
+async function api(route,options={}){
+  const {timeoutMs=6500,...request}=options;
+  const timeout=AbortSignal.timeout(timeoutMs);
+  const signal=request.signal ? AbortSignal.any([request.signal,timeout]) : timeout;
+  const pinned=local&&(state.server?.project?.id??state.overview?.projectKit?.projectId);
+  const headers={Accept:'application/json',...request.headers,...(pinned&&request.method==='POST'?{'X-Shadow-Brain-Project':pinned}:{})};
+  const response=await fetch('/api/workspace/'+route,{...request,signal,cache:'no-store',headers});
+  const data=await response.json().catch(()=>null);
+  if(!response.ok||!data){
+    const failure=new Error(data?.error ?? 'Workspace request returned HTTP '+response.status+'.');
+    failure.status=response.status;failure.code=data?.code;throw failure;
+  }
+  return data;
+}
+function validStatus(data){
+  return data&&typeof data.version==='string'&&/^\d+\.\d+\.\d+(?:[-+][\w.-]+)?$/.test(data.version)&&
+    typeof data.serverInstanceId==='string'&&data.serverInstanceId.length>0&&['project','shared','demo'].includes(data.mode)&&
+    (data.mode!=='project'||typeof data.project?.id==='string'&&typeof data.project.name==='string')&&
+    ['ready','error','initializing'].includes(data.storage?.status)&&data.capabilities?.memory===true;
+}
+function validOverview(data){return data&&typeof data.version==='string'&&Array.isArray(data.projects)&&data.totals&&data.projectKit;}
+function scopeName(){return state.overview?.projectKit?.projectName ?? arr(state.overview?.projects).find(project=>project.id===state.project)?.name ?? (state.project||'All projects');}
+function renderChrome(){
+  const selector=$('project');
+  const projects=arr(state.overview?.projects);
+  const fixed=state.overview?.projectKit?.projectId;
+  const options=(fixed?'':'<option value="">All projects</option>')+projects.map(project=>'<option value="'+esc(project.id)+'">'+esc(project.name)+'</option>').join('');
+  if(selector.dataset.options!==options){selector.innerHTML=options||'<option value="">Loading…</option>';selector.dataset.options=options;}
+  selector.disabled=!!fixed||!state.overview||state.pending;
+  selector.value=state.project;
+  const connection=$('connection');
+  const connected=state.connection==='reachable';
+  const isDemo=state.overview?.demo===true||state.server?.mode==='demo';
+  connection.className='chip '+(connected?'green':state.connection==='connecting'?'':'amber');
+  connection.innerHTML='<i class="dot" aria-hidden="true"></i> '+(connected?(isDemo?'Demo workspace · Example data':'Workspace reachable'):state.connection==='connecting'?'Connecting to workspace':'Workspace unavailable');
+  const notice=$('notice');
+  notice.textContent=state.connection==='offline'?'The local workspace did not respond. Keep this tab open while the launcher restarts the server, or refresh to retry. '+(state.overview?'Showing the last loaded snapshot.':''):
+    state.errors.overview||state.server?.storage?.status==='error'?'The server responded, but the memory store is unavailable. '+(state.errors.overview||state.server.storage.error||''):
+    state.replayExpired?'The selected replay record is outside the loaded history. Choose another record or return to latest.':
+    state.journalGap?'Some activity expired before this page could read it. The timeline shows retained records.':liveStream.notice??'';
+  $('scope-note').textContent=state.overview?(fixed?'Project-local workspace · ':'Global workspace · ')+scopeName()+(state.overview.version?' · v'+state.overview.version:''):'';
+  const buttons=Object.entries(nav).map(([id,label])=>'<button type="button" data-view="'+id+'" '+(id===state.view?'aria-current="page"':'')+'>'+label+'</button>').join('');
+  if($('nav').dataset.buttons!==buttons){$('nav').innerHTML=buttons;$('nav').dataset.buttons=buttons;}
+}
+function resetScope(){
+  state.dataEpoch++;state.viewEpoch++;state.graph=null;state.picked=null;state.memory=null;state.focus=false;state.context=null;
+  state.comparison=null;state.contextInput=null;state.hub=null;state.documents=null;state.room=null;state.profile=null;state.feedback=null;
+  state.skill=null;state.skillInput=null;state.search=null;state.events=[];state.cursor=undefined;state.journalId=undefined;state.lessonFrom=null;
+  state.replayId=null;state.replayExpired=false;state.journalGap=false;state.pulseIds=[];state.motionStarted=0;
+  state.policy=null;state.policySelection=null;state.managedSkills=null;state.managedSkillPlan=null;
+  if(typeof observedPulses!=='undefined'){observedPulses.clear();dockTool=null;dockSession=null;dockPinned=false;clearTimeout(dockPresenceTimer);}
+  state.presence=null;
+  clearTimeout(nativeTimer);state.nativeConnection=null;state.nativeThreads=null;state.nativeThread=null;state.nativeListCursor=null;state.nativeThreadCursor=null;state.nativeArchived=false;state.sessions=null;state.session=null;state.sessionBefore=null;state.sessionCheckpoint=null;state.usage=null;state.sources=null;state.source=null;state.evidence=null;state.teachDraft='';
+  state.graphEpoch++;state.graphFilter='all';state.listing=false;graphCamera=defaultCamera();
+}
+function updateOverview(value){
+  const fixed=value.projectKit?.projectId;
+  const next=fixed ?? (arr(value.projects).some(project=>project.id===state.project)?state.project:'');
+  if(next!==state.project){state.project=next;resetScope();}
+  state.overview=value;
+}
+function installTelemetry(page){
+  if(!page.liveEnabled){
+    state.events=[];state.cursor=undefined;state.journalId=undefined;state.live=false;state.recording=page.recordingEnabled;state.replayId=null;state.replayExpired=false;state.pulseIds=[];
+    return;
+  }
+  state.live=true;state.recording=page.recordingEnabled;
+  if(page.gap||page.reset||(state.journalId&&state.journalId!==page.journalId)){
+    state.events=[];state.journalGap=!!page.gap;state.pulseIds=[];
+  }
+  const hasHistory=state.cursor!==undefined;
+  const unique=new Map(state.events.map(event=>[event.id,event]));
+  const added=arr(page.events).filter(event=>!unique.has(event.id));
+  for(const event of added)unique.set(event.id,event);
+  if(added.length||unique.size!==state.events.length)state.events=[...unique.values()].sort((a,b)=>a.sequence-b.sequence).slice(-200);
+  state.cursor=page.cursor;
+  state.journalId=page.journalId;
+  if(state.replayId&&!state.events.some(event=>event.id===state.replayId))state.replayExpired=true;
+  if(state.suppressLivePulse){state.suppressLivePulse=false;return;}
+  if(hasHistory&&!page.gap&&!page.reset&&!page.hasMore&&typeof noteAgentActivity==='function')noteAgentActivity(added);
+  if(hasHistory&&!page.gap&&!page.reset&&!page.hasMore&&state.view==='overview'&&state.graphMode==='graph'&&!state.replayId&&!state.motionPaused&&!reduced.matches){
+    const now=Date.now();
+    const fresh=added.filter(event=>{
+      const age=now-Date.parse(event.timestamp);
+      return exchangeKey(event)&&age>=0&&age<=6500;
+    });
+    if(fresh.length){state.pulseIds=fresh.slice(-4).map(event=>event.id);state.motionStarted=performance.now();}
+  }
+}
+async function refresh(manual=false,areas=null){
+  if(document.hidden&&!manual)return;
+  clearTimeout(timer);
+  if(polling){if(areas)queueLive(areas);else pollAgain ||= manual;return;}
+  polling=true;
+  controller=new AbortController();
+  const signal=controller.signal;
+  const options={signal};
+  try{
+    const scope=state.view;
+    const needsHealth=!areas||!state.server,needsSummary=!areas||areas.has('graph');
+    const [health,summary]=await Promise.allSettled([
+      needsHealth?api('status',options):state.server,
+      needsSummary?api('overview',options):state.overview,
+    ]);
+    if(signal.aborted)return;
+    const old=state.server?.serverInstanceId;
+    const healthOk=health.status==='fulfilled'&&validStatus(health.value);
+    const summaryOk=summary.status==='fulfilled'&&validOverview(summary.value);
+    if(healthOk){
+      const next=health.value;
+      if(old&&next.serverInstanceId&&old!==next.serverInstanceId){resetScope();state.features=null;state.integrations=null;}
+      state.server=next;
+    }
+    const reachable=healthOk||summaryOk;
+    state.connection=reachable?'reachable':'offline';
+    if(summaryOk){updateOverview(summary.value);delete state.errors.overview;}
+    else if(reachable)state.errors.overview=summary.reason?.message??'The workspace returned an invalid overview.';
+    renderChrome();
+    if(!reachable){failures++;state.pulseIds=[];drawGraph();updateAgentDock();if(!$('title'))render();return;}
+    failures=0;
+    polls++;
+    const epoch=state.dataEpoch,graphEpoch=state.graphEpoch;
+    const params=new URLSearchParams(projectQuery({limit:'200'}).slice(1));
+    if(state.cursor!==undefined)params.set('cursor',state.cursor);
+    if(state.journalId)params.set('journalId',state.journalId);
+    const wanted=area=>!areas||areas.has(area);
+    const jobs=[];
+    if(local&&wanted('presence')&&dockVisible(scope))jobs.push(['presence',api('presence',options)]);
+    if(local&&(wanted('policy')||scope==='setup'&&wanted('sessions'))&&!state.pending&&
+      (['setup','sessions','context','overview'].includes(scope)||state.context))jobs.push(['policy',api('project-policy',options)]);
+    if(wanted('telemetry'))jobs.push(['telemetry',api('telemetry?'+params,options)]);
+    if(local&&wanted('usage')&&['models','usage','sessions','overview'].includes(scope))jobs.push(['usage',api('usage',options)]);
+    if(local&&wanted('sessions')&&dockVisible(scope)&&!state.pending){
+      jobs.push(['sessions',api('sessions',options)]);
+      if(scope==='sessions'&&state.session)jobs.push(['session',api('sessions/'+state.session.session.id+(state.sessionBefore?'?before='+encodeURIComponent(state.sessionBefore):''),options)]);
+    }
+    if(local&&wanted('feedback')&&scope==='learning'&&!state.pending)jobs.push(['feedback',api('project-feedback',options)]);
+    if(local&&wanted('sources')&&scope==='knowledge'&&!state.pending){
+      jobs.push(['sources',api('sources',options)]);
+      if(state.source)jobs.push(['source',api('sources/'+encodeURIComponent(state.source.id),options)]);
+    }
+    if(wanted('graph')&&(!state.graph||manual||(scope==='overview'&&(areas||polls%3===0||state.graph.totalMemories!==state.overview?.quality?.total))))jobs.push(['graph',api('graph'+projectQuery({limit:graphMemoryLimit,...(state.picked?.startsWith('memory:')?{memory:state.picked.slice(7)}:{})}),options)]);
+    if(wanted('features')&&(!state.features||manual||areas||scope==='setup'))jobs.push(['features',api('features',options)]);
+    if(local&&wanted('hub')&&state.server?.capabilities?.hub!==false&&!state.pending&&(!state.hub||manual||['room','knowledge','learning'].includes(scope)))jobs.push(['hub',api('hub',options)]);
+    if(local&&wanted('hub')&&!state.pending&&scope==='room'&&state.room)jobs.push(['room',api('hub/rooms/'+encodeURIComponent(state.room.room.id),options)]);
+    const results=await Promise.allSettled(jobs.map(([,job])=>job));
+    if(signal.aborted||epoch!==state.dataEpoch)return;
+    let needsRender=false;
+    results.forEach((result,index)=>{
+      const name=jobs[index][0];
+      if(result.status==='rejected'){needsRender ||= state.errors[name]!==result.reason.message;state.errors[name]=result.reason.message;return;}
+      needsRender ||= !!state.errors[name];
+      delete state.errors[name];
+      if(name==='policy'){const changed=installPolicy(result.value);needsRender ||= scope!=='overview'&&changed;return;}
+      if(name==='presence'){installDockPresence(result.value);scheduleDockExpiry();return;}
+      if(name==='session'&&state.session?.session.id!==result.value.session.id)return;
+      if(name==='source'){
+        if(state.source?.id!==result.value.source.id)return;
+        needsRender ||= state.view==='knowledge'&&JSON.stringify(state.source)!==JSON.stringify(result.value.source);
+        state.source=result.value.source;return;
+      }
+      if(name==='sessions'||name==='session'||name==='sources'){needsRender ||= scope!=='overview'&&state.view===scope&&JSON.stringify(state[name])!==JSON.stringify(result.value);state[name]=result.value;}
+      else if(name==='feedback'){needsRender ||= state.view==='learning'&&state.feedback?.revision!==result.value.revision;state.feedback=result.value;}
+      else if(name==='usage'){needsRender ||= ['models','usage','sessions'].includes(state.view)&&JSON.stringify(state.usage)!==JSON.stringify(result.value);state.usage=result.value;}
+      else if(name==='telemetry'){const before=JSON.stringify([state.live,state.recording,state.cursor,state.events.map(event=>event.id)]);installTelemetry(result.value);needsRender ||= ['models','usage'].includes(state.view)&&before!==JSON.stringify([state.live,state.recording,state.cursor,state.events.map(event=>event.id)]);if(result.value.hasMore)pollAgain=true;}
+      else if(name==='graph'&&graphEpoch===state.graphEpoch&&JSON.stringify(state.graph)!==JSON.stringify(result.value)){state.graph=result.value;needsRender ||= state.view==='overview';}
+      else if(name==='features'&&(!state.features||result.value.revision>=state.features.revision)){
+        needsRender ||= state.view==='setup'&&state.features?.revision!==result.value.revision;
+        state.features=result.value;
+      }else if(name==='hub'&&(!state.hub||result.value.revision>=state.hub.revision)){
+        needsRender ||= ['room','knowledge','learning'].includes(state.view)&&state.hub?.revision!==result.value.revision;
+        state.hub=result.value;
+      }else if(name==='room'&&state.room?.room?.id===result.value.room.id&&result.value.revision>=state.room.revision){
+        needsRender ||= state.view==='room'&&state.room.revision!==result.value.revision;
+        state.room=result.value;
+      }
+    });
+    syncProjectStream();streamBadge();renderChrome();
+    if(local&&(!areas||areas.has('features'))&&state.features?.features?.projectFileActivity)void readLiveFiles();
+    if(state.view==='overview'){
+      if(manual||!$('brain-stage')||needsRender)render(true);
+      else updateOverviewLive();
+    }else if(manual||!$('title')||needsRender)render(true);
+    updateAgentDock();
+    if(manual)await loadView();
+  } finally {
+    polling=false;controller=undefined;
+    if(!document.hidden){
+      const delay=pollAgain?20:failures?Math.min(15000,1800*2**Math.min(3,failures-1)):local&&liveStream.status==='off'?5000:2600;
+      const next=local&&liveStream.status==='live'?new Set(['telemetry']):null;
+      if(pollAgain||!next){pollAgain=false;timer=setTimeout(()=>void refresh(false,next),delay);}
+    }
+  }
+}
+async function loadView(){
+  const epoch=++state.viewEpoch;
+  const current=state.view;
+  const jobs=[];
+  if(current==='setup')jobs.push(['integrations','integrations']);
+  if(local&&current==='setup')jobs.push(['managedSkills','managed-skills']);
+  if(local&&['setup','sessions','context'].includes(current))jobs.push(['policy','project-policy']);
+  if(current==='knowledge'||current==='room'||current==='learning'){
+    if(local&&!state.hub)jobs.push(['hub','hub']);
+    if(local&&current==='knowledge'&&!state.profile)jobs.push(['profile','project-profile']);
+    if(local&&current==='learning')jobs.push(['feedback','project-feedback']);
+  }
+  if(local&&current==='sessions')jobs.push(['sessions','sessions']);
+  if(local&&current==='overview'&&!state.sessions)jobs.push(['sessions','sessions']);
+  if(local&&current==='overview'&&!state.usage)jobs.push(['usage','usage']);
+  if(local&&current==='overview'&&!state.policy)jobs.push(['policy','project-policy']);
+  if(local&&dockVisible(current))jobs.push(['presence','presence']);
+  if(local&&['models','usage','sessions'].includes(current))jobs.push(['usage','usage']);
+  if(local&&current==='knowledge')jobs.push(['sources','sources']);
+  if(current==='models')jobs.push(['integrations','integrations']);
+  const results=await Promise.allSettled(jobs.map(([,url])=>api(url)));
+  if(epoch!==state.viewEpoch||current!==state.view)return;
+  results.forEach((result,index)=>{
+    const name=jobs[index][0];
+    if(result.status==='fulfilled'){
+      if(name==='policy')installPolicy(result.value);
+      else if(name==='presence')installDockPresence(result.value);
+      else state[name]=result.value;
+      delete state.errors[name];
+    }
+    else state.errors[name]=result.reason.message;
+  });
+  if(jobs.length)render(true);
+  scheduleDockExpiry();
+  if(local&&current==='sessions')void refreshNativeChats();
+  if(local&&current==='sessions')void readLiveFiles();
+}
+function openView(next){
+  if(!Object.hasOwn(nav,next))return;
+  state.view=next;state.message='';state.messageError=false;state.pulseIds=[];
+  scheduleDockExpiry();
+  render();window.scrollTo(0,0);$('title')?.focus({preventScroll:true});void loadView();
+}
+function render(restore=false){
+  const dockFocus=$('tool-dock')?.contains(document.activeElement)?document.activeElement:null;
+  const policyToolsOpen=$('policy-tools')?.open;
+  const finder=$('node-list');
+  const finderFocus=finder?.contains(document.activeElement)?document.activeElement:null;
+  const finderDraft=$('graph-search')?.value;
+  const formValues=restore?[...$('main').querySelectorAll('form[data-form]')].map(form=>{
+    const fields=[...form.elements].filter(node=>node.name&&node.type!=='submit'&&node.type!=='button');
+    return {kind:form.dataset.form,id:form.dataset.id,item:form.dataset.item,fields:fields.map(node=>({name:node.name,value:node.value,checked:node.checked,
+      file:node.type==='file'?node:null,active:node===document.activeElement,start:node.selectionStart,end:node.selectionEnd}))};
+  }):[];
+  unmountGraph();
+  renderChrome();
+  const viewBody=views[state.view]();
+  $('main').innerHTML=viewBody+'<p class="status small" id="view-status" role="status"></p>';
+  updateAgentDock();
+  if(dockFocus?.dataset.dockTool)focusDockTool(dockFocus.dataset.dockTool);
+  else if(dockFocus?.dataset.dockRecord)[...$('tool-dock')?.querySelectorAll('[data-dock-record]')??[]].find(button=>button.dataset.dockRecord===dockFocus.dataset.dockRecord)?.focus({preventScroll:true});
+  else if(dockFocus?.id)$(dockFocus.id)?.focus({preventScroll:true});
+  if(policyToolsOpen&&$('policy-tools'))$('policy-tools').open=true;
+  status(state.message,state.messageError);
+  if(state.view==='overview'){mountGraph();updateLiveFilePulse();}
+  if(state.listing&&typeof finderDraft==='string'&&$('graph-search'))$('graph-search').value=finderDraft;
+  if(finderFocus&&state.listing){
+    const next=finderFocus.id==='graph-search'?$('graph-search'):[...$('node-list')?.querySelectorAll('button')??[]].find(button=>
+      button.dataset.node===finderFocus.dataset.node&&button.dataset.graphMemory===finderFocus.dataset.graphMemory&&button.type===finderFocus.type);
+    next?.focus({preventScroll:true});
+  }
+  for(const form of $('main').querySelectorAll('form[data-form]')){
+    const saved=formValues.find(item=>item.kind===form.dataset.form&&item.id===form.dataset.id&&item.item===form.dataset.item);
+    if(!saved)continue;
+    for(const field of saved.fields){
+      let node=form.elements.namedItem(field.name);
+      if(!node)continue;
+      if(field.file?.files?.length){node.replaceWith(field.file);node=field.file;}
+      else if(node.type!=='file'&&(node.tagName!=='SELECT'||[...node.options].some(option=>option.value===field.value)))node.value=field.value;
+      if(node.type==='checkbox')node.checked=field.checked;
+      if(field.active){node.closest('details')?.setAttribute('open','');node.focus({preventScroll:true});if(field.start!==null)node.setSelectionRange?.(field.start,field.end);}
+    }
+  }
+  $('main').querySelectorAll('[id^="policy-"][type="range"]').forEach(reflectPolicySlider);
+}
+async function chooseMemory(id){
+  const item=arr(state.graph?.nodes).find(node=>node.id===id);
+  if(!item)return;
+  state.picked=id;state.memory=null;state.focus=true;state.inspector='record';state.pulseIds=[];
+  if(graphCamera.scale>1&&graphSurface?.points.has(id)){
+    const point=graphSurface.points.get(id);
+    graphCamera.x=(graphSurface.width/2-point.x)*graphCamera.scale;
+    graphCamera.y=(graphSurface.height/2-point.y)*graphCamera.scale;
+    boundCamera(graphSurface);
+  }
+  renderInspector();drawGraph();
+  if(item.kind!=='memory')return;
+  const epoch=state.dataEpoch;
+  try{
+    const detail=await api('memory?'+new URLSearchParams({id:item.memoryId,project:item.project}));
+    if(epoch!==state.dataEpoch||state.picked!==id)return;
+    state.memory=detail;renderInspector();
+  }catch(failure){if(epoch===state.dataEpoch&&state.picked===id)status(failure.message,true);}
+}
+async function loadDocuments(id){state.documents=await api('hub/documents/'+encodeURIComponent(id));state.docPage=arr(state.documents.pages)[0]?.page??1;}
+async function loadRoom(id){state.room=await api('hub/rooms/'+encodeURIComponent(id));}
+async function refreshHub(){state.hub=await api('hub');delete state.errors.hub;}
+async function refreshGraph(){state.graph=await api('graph'+projectQuery({limit:graphMemoryLimit}));delete state.errors.graph;}
+function field(form,name){return String(form.get(name)??'').trim();}
+async function clipboard(text){
+  if(!text)throw new Error('There is no text to copy.');
+  await navigator.clipboard.writeText(text);
+  status('Copied to clipboard.');
+}
+async function mutation(operation,source,success='Saved.'){
+  if(state.pending)return;
+  state.pending=true;
+  const submissionView=state.view;
+  if(source)source.disabled=true;
+  renderChrome();
+  status('Working…');
+  try{
+    const message=await operation();
+    state.pending=false;status(typeof message==='string'?message:success);render(state.view!==submissionView);
+    if(source?.dataset.feature)[...$('main').querySelectorAll('[data-feature]')].find(node=>node.dataset.feature===source.dataset.feature)?.focus({preventScroll:true});
+    if(source?.dataset.policyTool||source?.dataset.policyChat)[...$('main').querySelectorAll('[data-policy-tool],[data-policy-chat]')].find(node=>
+      source.dataset.policyTool?node.dataset.policyTool===source.dataset.policyTool:node.dataset.policyChat===source.dataset.policyChat)?.focus({preventScroll:true});
+  }
+  catch(failure){
+    if(failure.status===409){
+      if(source?.dataset.feature){try{state.features=await api('features');render(true);}catch{}}
+      else if(source?.dataset.action?.startsWith('managed-skill-')){state.managedSkillPlan=null;try{state.managedSkills=await api('managed-skills');render(true);}catch{}}
+      else if(source?.closest?.('[data-form=feedback]')||['toggle-feedback','remove-feedback'].includes(source?.dataset.action)){try{state.feedback=await api('project-feedback');render(true);}catch{}}
+      else if(source?.dataset.roomAction&&state.room){try{await loadRoom(state.room.room.id);render(true);}catch{}}
+    }
+    status(failure.message||'The workspace request failed.',true);
+  }finally{
+    state.pending=false;
+    if(source)source.disabled=false;
+    $('main').querySelectorAll('button[type=submit]').forEach(node=>node.disabled=false);
+    renderChrome();
+  }
+}
+async function afterSave(...refreshers){
+  const results=await Promise.allSettled(refreshers.map(refresh=>refresh()));
+  return results.some(result=>result.status==='rejected')?'Saved. Refresh the workspace to reload related records.':undefined;
+}
+function setReplay(index){
+  const event=state.events[index];
+  if(!event)return;
+  state.replayId=event.id;state.replayExpired=false;state.pulseIds=[];state.inspector='event';state.focus=false;
+  renderChrome();
+  updateOverviewLive();renderInspector();drawGraph();
+}
+function start(){
+  render();
+  $('reload').addEventListener('click',()=>void refresh(true));
+  $('project').addEventListener('change',event=>{
+    state.project=event.target.value;resetScope();render();void refresh(true);
+  });
+  $('main').addEventListener('input',event=>{if(event.target.id==='replay')setReplay(Number(event.target.value));else reflectPolicySlider(event.target);});
+  $('main').addEventListener('change',event=>{
+    if(event.target.id==='policy-chat'){state.policySelection=event.target.value;render();$('policy-chat')?.focus();}
+  });
+  $('main').addEventListener('focusin',event=>previewDockTool(event.target));
+  $('main').addEventListener('pointerover',event=>{if(event.pointerType==='mouse')previewDockTool(event.target);});
+  $('main').addEventListener('keydown',event=>{
+    if(event.key==='Escape'&&dockTool&&event.target.closest('#tool-dock')){
+      const close=$('tool-dock')?.querySelector('[data-dock-close]');
+      if(close){event.preventDefault();handleAgentDock(close);}
+    }
+  });
+  document.addEventListener('visibilitychange',()=>{
+    clearTimeout(timer);state.pulseIds=[];drawGraph();updateAgentDock();scheduleDockExpiry();
+    if(document.hidden){controller?.abort();stopProjectStream();}else {state.suppressLivePulse=!!liveStream.cursor;void refresh(true);}
+  });
+  reduced.addEventListener('change',()=>{state.pulseIds=[];updateOverviewLive();updateAgentDock();});
+  window.addEventListener('online',()=>void refresh(true));
+  document.addEventListener('click',handleClick);
+  document.addEventListener('submit',handleSubmit);
+  void refresh(true);
+}
+`;
+//# sourceMappingURL=brain-hub-client.js.map

package/dist/dashboard/brain-hub-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brain-hub-client.js","sourceRoot":"","sources":["../../src/dashboard/brain-hub-client.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAibzC,CAAC"}

package/dist/dashboard/brain-hub-context.d.ts

@@ -0,0 +1,2 @@
+export declare const BRAIN_HUB_CONTEXT: string;
+//# sourceMappingURL=brain-hub-context.d.ts.map

package/dist/dashboard/brain-hub-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brain-hub-context.d.ts","sourceRoot":"","sources":["../../src/dashboard/brain-hub-context.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,QAmC7B,CAAC"}

package/dist/dashboard/brain-hub-context.js

@@ -0,0 +1,37 @@
+export const BRAIN_HUB_CONTEXT = String.raw `
+function memoryActions(id){return '<div class="actions">'+action('open-memory','Inspect memory','','data-memory="'+esc(id)+'"')+(local?action('source-evidence','Original source','','data-memory="'+esc(id)+'"'):'')+'</div>';}
+function contextDiagnostics(pack){
+  const retrieval=pack.retrieval;
+  const stages=retrieval?'<dl class="facts">'+arr(retrieval.stages).map(stage=>fact(stage.label,stage.count)).join('')+fact('Task classification',retrieval.taskType)+fact('Candidate limit',retrieval.candidateLimit)+fact('Scan truncated',retrieval.truncated?'Yes':'No')+'</dl>':'';
+  const candidates=retrieval?list(arr(retrieval.candidates).map(candidate=>'<li class="item"><div class="row"><strong>'+esc(candidate.title)+'</strong>'+chip(candidate.decision==='selected'?'Selected':candidate.reason,candidate.decision==='selected'?'green':'amber')+'</div><p class="small muted">Rank '+esc(candidate.rank)+' · matched '+esc(arr(candidate.matchedTerms).join(', ')||'no terms')+' in '+esc(arr(candidate.matchedFields).join(', ')||'no fields')+'</p><details><summary>Why this rank?</summary><dl class="facts">'+arr(candidate.signals).map(signal=>fact(signal.label,Number(signal.value).toFixed(3))).join('')+(candidate.feedback?fact('Feedback adjustment',candidate.feedback.adjustment):'')+'</dl>'+arr(candidate.paths).map(path=>'<p class="small mono">'+esc(path.relationType+' from '+path.seedId+' via '+path.relationId)+'</p>').join('')+'</details>'+memoryActions(candidate.id)+'</li>').join('')):'';
+  const omitted=arr(pack.excluded);
+  const reasons={budget:'Would exceed the context budget',limit:'Outside the selected memory count',duplicate:'Duplicate of another memory',empty:'No usable text',lookback:'Outside the time window',archived:'Archived',contested:'Marked contested',superseded:'Replaced by a newer memory'};
+  return panel('How the pack was chosen','<div class="panel-body stack">'+stages+'<p class="small muted">Ranks are retrieval signals, not factual confidence or an accuracy score. Exact characters: '+fmt(pack.budget.usedChars)+'. '+(Number.isFinite(pack.budget.usedBytes)?'UTF-8 bytes: '+fmt(pack.budget.usedBytes)+'. ':'')+'Token estimator: '+esc(pack.budget.estimator??'character heuristic')+'.</p></div>'+candidates+(omitted.length?'<details class="panel-body"><summary>'+omitted.length+' omitted records</summary>'+list(omitted.map(entry=>'<li class="item"><strong>'+esc(entry.title??entry.id)+'</strong><p class="small muted">'+esc(reasons[entry.reason]??entry.reason)+'</p>'+memoryActions(entry.id)+'</li>').join(''))+'</details>':''));
+}
+function contextComparison(){
+  const compare=state.comparison;if(!compare)return '';
+  const titles=new Map([...arr(compare.legacy.entries),...arr(compare.adaptive.entries)].map(entry=>[entry.id,entry.excerpt]));
+  return panel('What changed between retrieval profiles','<div class="panel-body stack"><dl class="facts">'+fact('Legacy estimate',compare.legacy.budget.estimatedTokens+' tokens')+fact('Adaptive estimate',compare.adaptive.budget.estimatedTokens+' tokens')+'</dl>'+arr(compare.warnings).map(warning=>'<p class="small muted">'+esc(warning)+'</p>').join('')+[['addedIds','Added by adaptive'],['removedIds','Only in legacy'],['sharedIds','Selected by both']].map(([key,label])=>'<h3>'+label+' · '+arr(compare.delta?.[key]).length+'</h3>'+list(arr(compare.delta?.[key]).map(id=>'<li class="item"><p>'+esc(titles.get(id)??id)+'</p>'+memoryActions(id)+'</li>').join(''))).join('')+'</div>');
+}
+function contextEfficiencyPanel(pack){
+  const result=pack?.efficiency;if(!result)return '';
+  const difference=result.signedTokenDifference;
+  const label=difference<0?fmt(-difference)+' more estimated context tokens':fmt(difference)+' estimated context tokens avoided';
+  const percent=result.referenceEstimatedTokens?Math.abs(difference)/result.referenceEstimatedTokens*100:null;
+  const change=percent===null?'No reference context':difference===0?'Same estimated size':percent.toFixed(1)+(difference<0?'% larger':'% smaller');
+  return panel('Context efficiency','<div class="panel-body stack"><div class="row"><strong>'+label+'</strong>'+chip(change,difference<0?'amber':'cyan')+'</div><dl class="facts">'+fact('Bounded reference pack',fmt(result.referenceEstimatedTokens)+' estimated tokens')+fact('Focused pack',fmt(result.focusedEstimatedTokens)+' estimated tokens')+fact('Reference / selected memories',result.referenceMemoryCount+' / '+result.focusedMemoryCount)+fact('Measured assembly time',result.assemblyMs+' ms')+fact('Comparison overhead',result.referenceComparisonMs+' ms')+'</dl><p class="small muted">'+esc(result.baseline)+'. Reference cap: '+result.referenceTokenBudget+' tokens / '+result.referenceEntryLimit+' entries.'+(result.referenceLimited?' The reference also reached a scan or pack limit.':'')+'</p><p class="small muted">'+esc(result.note)+'</p></div>',chip('Estimate'));
+}
+function contextPage(){
+  const input=state.contextInput??{};
+  const enabled=state.features?.features?.contextAssembly!==false;
+  const controls=state.policy?.policy;
+  const form='<div class="panel-body"><form class="form" data-form="context"><label>What are you working on?<textarea name="query" rows="4" maxlength="4096" placeholder="Describe your next task in your own words">'+esc(input.query)+'</textarea></label><p class="small muted">The brain searches approved project memory for this task. The connected agent uses the returned context to reason about your work.</p><div class="form-grid"><label>Context size · estimated tokens<input name="tokenBudget" type="number" min="0" max="12000" value="'+esc(input.tokenBudget??2000)+'" required></label><label>Retrieval method<select name="profile"><option value="adaptive">Adaptive</option><option value="legacy" '+(input.profile==='legacy'?'selected':'')+'>Legacy</option></select></label></div><label class="check"><input name="expandRelated" type="checkbox" '+(input.expandRelated?'checked':'')+'> Include recorded related memories</label><div class="actions">'+(state.project&&enabled?submit('Find useful context')+'<button class="btn" type="submit" name="compare" value="yes">Compare methods</button>':chip(state.project?'Context packs disabled':'Select a project','amber'))+'</div></form></div>';
+  const pack=state.context;
+  const output=pack?'<div class="panel-body stack"><div class="row"><strong>'+fmt(arr(pack.entries).length)+' selected memories</strong>'+chip(fmt(pack.budget.estimatedTokens)+' estimated tokens','pink')+'</div>'+arr(pack.warnings).map(warning=>'<p class="small amber">'+esc(warning)+'</p>').join('')+(arr(pack.entries).length?list(pack.entries.map(entry=>'<li class="item"><p class="preserve">'+esc(entry.excerpt)+'</p><small class="muted">'+esc(arr(entry.reasons).join(' · '))+'</small><small class="mono cyan">'+esc(arr(entry.sources).join(' · '))+'</small>'+memoryActions(entry.id)+'</li>').join('')):empty('No matching memories fit this pack','Add relevant notes, change the task description, or increase the budget.'))+'<div class="actions">'+action('copy-pack','Copy context','primary')+view('learning','Review usefulness')+'</div><details><summary>Exact context available to copy</summary><pre>'+esc(pack.markdown)+'</pre></details></div>':empty('Try your next task','See exactly which memories are selected and where each one came from.');
+  const preview=pack?.policy??controls?.context;
+  const ceiling=preview?'<p class="panel-body small muted">Project ceilings · '+fmt(preview.maxTokens)+' estimated tokens · '+fmt(preview.maxEntries)+' entries'+
+    (pack?.policy?' · policy revision '+fmt(pack.policy.revision):'')+'. '+(pack?.policy?.hiddenMemories?fmt(pack.policy.hiddenMemories)+' linked memories withheld from delivery.':'')+'</p>':'';
+  return heading('Context for your next task','Find relevant project knowledge and inspect the delivery preview.',view('knowledge','Add knowledge'))+'<div class="two">'+panel('Your task',form+ceiling,chip(scopeName()))+panel('Selected context',output)+'</div>'+contextEfficiencyPanel(pack)+contextComparison()+(pack?contextDiagnostics(pack):'');
+}
+`;
+//# sourceMappingURL=brain-hub-context.js.map

package/dist/dashboard/brain-hub-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brain-hub-context.js","sourceRoot":"","sources":["../../src/dashboard/brain-hub-context.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmC1C,CAAC"}

package/dist/dashboard/brain-hub-controls.d.ts

@@ -0,0 +1,2 @@
+export declare const BRAIN_HUB_CONTROLS: string;
+//# sourceMappingURL=brain-hub-controls.d.ts.map

package/dist/dashboard/brain-hub-controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brain-hub-controls.d.ts","sourceRoot":"","sources":["../../src/dashboard/brain-hub-controls.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,QA6D9B,CAAC"}

package/dist/dashboard/brain-hub-controls.js

@@ -0,0 +1,63 @@
+export const BRAIN_HUB_CONTROLS = String.raw `
+function projectControls(){
+  if(!local)return '';
+  if(state.errors.policy)return panel('Project sharing',error('policy','project controls'));
+  const view=state.policy;
+  if(!view)return panel('Project sharing',empty('Loading project controls','Reading sharing and context preferences.'));
+  const snapshot=view.policy;
+  const disabled=state.pending?' disabled':'';
+  const slider=(name,label,min,max,value,suffix)=>'<label><span class="row">'+esc(label)+' <output class="mono cyan" for="policy-'+name+'" data-policy-output="'+name+'">'+fmt(value)+'</output></span>'+
+    '<input id="policy-'+name+'" name="'+name+'" type="range" min="'+min+'" max="'+max+'" value="'+value+'" aria-label="'+esc(label)+'" aria-valuetext="'+fmt(value)+' '+suffix+'"'+disabled+'></label>';
+  const ceilings='<form class="form" data-form="policy-context">'+slider('maxTokens','Maximum estimated context tokens',200,12000,snapshot.context.maxTokens,'estimated tokens')+
+    slider('maxEntries','Maximum context entries',1,30,snapshot.context.maxEntries,'entries')+submit('Save context limits')+'</form>';
+  const tools=list(arr(view.tools).map(tool=>{
+    const on=arr(snapshot.tools).find(entry=>entry.tool===tool)?.enabled!==false;
+    return '<li class="item"><div class="row"><strong>'+esc(hostName(tool))+'</strong>'+btn(on?'Enabled':'Disabled','role="switch" aria-checked="'+on+'" aria-label="Allow '+esc(hostName(tool))+
+      ' to use project tools" data-policy-tool="'+esc(tool)+'" data-enabled="'+!on+'"'+disabled)+'</div></li>';
+  }).join(''),'aria-label="Project tools"');
+  const candidates=arr(view.chats);
+  const selected=candidates.find(chat=>chat.id===state.policySelection)??candidates[0];
+  const chats=selected?'<div class="stack"><label class="form">Conversation<select id="policy-chat"><option value="" disabled>Select a conversation</option>'+
+    candidates.map(chat=>'<option value="'+esc(chat.id)+'" '+(chat.id===selected.id?'selected':'')+'>'+esc(chat.title)+' · '+esc(hostName(chat.tool))+'</option>').join('')+
+    '</select></label><div class="row"><span>Share context from this chat</span>'+btn(selected.shareContext?'Sharing':'Private to operator',
+      'role="switch" aria-label="Share context from the selected chat" aria-checked="'+!!selected.shareContext+'" data-policy-chat="'+esc(selected.id)+'" data-enabled="'+!selected.shareContext+'"'+disabled)+
+    '</div>'+(selected.inheritedBlocked?'<p class="small amber">An earlier handoff in this conversation is unavailable to agents.</p>':'')+
+    '<form class="form" data-form="policy-role" data-id="'+esc(selected.id)+'"><label>Coordination role<select name="role">'+
+      [['','Unassigned'],['lead','Lead'],['worker','Worker'],['observer','Observer']].map(([value,label])=>'<option value="'+value+'" '+((selected.role??'')===value?'selected':'')+'>'+label+'</option>').join('')+
+    '</select></label>'+submit('Save role','')+'</form></div>':empty('No shared conversations yet','Open or import a conversation to set its sharing and role.');
+  return panel('Project sharing','<div class="panel-body stack"><div class="two"><section class="stack"><h3>Context limits</h3>'+ceilings+'</section>'+
+    '<section class="stack"><h3>Conversation access</h3>'+chats+'</section></div><details id="policy-tools"><summary>Tool participation</summary>'+tools+
+    '<p class="small muted">Applies to client labels connected to this project’s Shadow Brain. Role assignments are coordination labels.</p></details></div>',chip('Revision '+snapshot.revision));
+}
+function installPolicy(value){
+  if(state.policy?.policy.revision>value.policy.revision)return false;
+  const changed=JSON.stringify(state.policy)!==JSON.stringify(value);
+  const prior=state.context?.policy?.revision;
+  state.policy=value;
+  if(prior!==undefined&&prior!==value.policy.revision){
+    state.context=null;state.comparison=null;
+    if(state.view==='context')status('Project controls changed. Build a fresh context pack.');
+  }
+  return changed;
+}
+async function saveProjectPolicy(command){
+  if(!state.policy)return;
+  try {
+    const result=await api('project-policy',json({...command,expectedRevision:state.policy.policy.revision}));
+    installPolicy(result);delete state.errors.policy;
+  }catch(failure){
+    if(failure.status===409){
+      try{installPolicy(await api('project-policy'));render(true);}catch{}
+    }
+    throw failure;
+  }
+}
+function reflectPolicySlider(target){
+  if(!target.id?.startsWith('policy-')||target.type!=='range')return;
+  const output=target.parentElement.querySelector('output');
+  const text=fmt(Number(target.value));
+  if(output)output.textContent=text;
+  target.setAttribute('aria-valuetext',text+(target.name==='maxTokens'?' estimated tokens':' entries'));
+}
+`;
+//# sourceMappingURL=brain-hub-controls.js.map

package/dist/dashboard/brain-hub-controls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brain-hub-controls.js","sourceRoot":"","sources":["../../src/dashboard/brain-hub-controls.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6D3C,CAAC"}

package/dist/dashboard/brain-hub-exchanges.d.ts

@@ -0,0 +1,2 @@
+export declare const BRAIN_HUB_EXCHANGES: string;
+//# sourceMappingURL=brain-hub-exchanges.d.ts.map

package/dist/dashboard/brain-hub-exchanges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brain-hub-exchanges.d.ts","sourceRoot":"","sources":["../../src/dashboard/brain-hub-exchanges.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,QAgF/B,CAAC"}