@theihtisham/agent-shadow-brain 7.1.4 → 7.22.0

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

@@ -1,37 +1,133 @@
 export const BRAIN_HUB_GRAPH = String.raw `
 const tones={project:'124,233,232',memory:'172,199,255',agent:'234,172,249',measured:'124,233,232',reported:'250,208,140'};
+const relationColors={supports:'91,209,221',related:'119,165,221',contradicts:'227,175,119',supersedes:'150,154,222'};
+const graphMemoryLimit='500';
 let graphSurface=null;
+const defaultCamera=()=>({scale:1,x:0,y:0});
+let graphCamera=defaultCamera();
+function graphFinderResults(){
+  const search=state.search;
+  if(!search)return '<div class="graph-results" id="graph-results">'+list(arr(state.graph?.nodes).map(node=>
+    '<li><button class="entry" type="button" data-node="'+esc(node.id)+'" aria-pressed="'+(state.focus&&state.picked===node.id)+'"><strong>'+
+    esc(node.kind==='agent'?hostName(node.label):node.label)+'</strong><small class="muted">'+esc(node.kind+(node.category?' · '+node.category:''))+'</small></button></li>').join(''),
+    'aria-label="Displayed graph records"')+'</div>';
+  const items=arr(search.items);
+  return '<div class="graph-results" id="graph-results" aria-busy="'+!!search.loading+'"><p class="small muted graph-search-note" role="status">'+
+    esc(search.error??(search.loading?'Searching stored memories…':items.length?fmt(items.length)+' of '+fmt(search.total)+' matches'+(search.truncated?' · bounded inventory':''):'No matching memories in this scope.'))+'</p>'+
+    (items.length?list(items.map(item=>'<li><button class="entry" type="button" data-graph-memory="'+esc(item.id)+'" data-graph-project="'+esc(item.project)+
+      '"><strong>'+esc(item.title||item.id)+'</strong><small class="muted">'+esc(item.category+' · '+hostName(item.agent)+(item.projectName?' · '+item.projectName:''))+'</small></button></li>').join(''),'aria-label="Stored memory search results"'):'')+'</div>';
+}
+function graphFinderMarkup(hidden){
+  return '<div id="node-list" class="node-list graph-finder" '+(hidden?'hidden':'')+'><form id="graph-find-form" class="graph-find" role="search" aria-label="Find stored memories">'+
+    '<label for="graph-search" class="sr-only">Find stored memories in this scope</label><input id="graph-search" name="query" type="search" value="'+esc(state.search?.query)+
+    '" placeholder="Search all stored memories" maxlength="180"><button class="btn" type="submit">Search</button>'+action('clear-graph-search','Clear','quiet')+
+    '</form>'+graphFinderResults()+'</div>';
+}
+async function findGraphMemories(query){
+  const epoch=state.dataEpoch;
+  const search=query?{query,loading:true}:null;
+  state.search=search;
+  const field=$('graph-search'),results=$('graph-results');
+  if(field)field.value=query;
+  if(results)results.outerHTML=graphFinderResults();
+  if(!search)return;
+  try{Object.assign(search,await api('memories'+projectQuery({q:query,limit:'30'})));}
+  catch(failure){search.error=failure.message;}
+  if(epoch!==state.dataEpoch||state.search!==search)return;
+  search.loading=false;
+  const result=$('graph-results');
+  if(result)result.outerHTML=graphFinderResults();
+}
+async function focusGraphMemory(id,project){
+  const dataEpoch=state.dataEpoch,graphEpoch=++state.graphEpoch;
+  const query=projectQuery({limit:graphMemoryLimit,memory:id});
+  try{
+    const graph=await api('graph'+query);
+    if(dataEpoch!==state.dataEpoch||graphEpoch!==state.graphEpoch||state.view!=='overview')return;
+    if(!arr(graph.nodes).some(node=>node.memoryId===id&&node.project===project))throw new Error('The memory is no longer available in this scope.');
+    state.graphEpoch++;state.graph=graph;state.listing=false;render();
+    const details=chooseMemory('memory:'+id);
+    $('main').querySelector('[data-inspect=record]')?.focus({preventScroll:true});
+    await details;
+  }catch(failure){if(dataEpoch===state.dataEpoch&&graphEpoch===state.graphEpoch&&state.view==='overview')status(failure.message,true);}
+}
+function filterGraph(value){
+  if(!['all','project','author','typed'].includes(value))return;
+  state.graphFilter=value;
+  drawGraph();syncGraphControls();
+}
+const graphCoordinates=(surface,x,y)=>({x:(x-surface.width/2-graphCamera.x)/graphCamera.scale+surface.width/2,
+  y:(y-surface.height/2-graphCamera.y)/graphCamera.scale+surface.height/2});
+function boundCamera(surface){
+  const dx=(graphCamera.scale-1)*surface.width/2,dy=(graphCamera.scale-1)*surface.height/2;
+  graphCamera.x=Math.max(-dx,Math.min(dx,graphCamera.x));
+  graphCamera.y=Math.max(-dy,Math.min(dy,graphCamera.y));
+}
+function zoomGraph(direction){
+  if(!graphSurface)return;
+  const before=graphCamera.scale;
+  const scale=direction==='fit'?1:Math.round(Math.max(1,Math.min(3,before+direction*.5))*10)/10;
+  const point=state.focus&&graphSurface.points.get(state.picked);
+  if(point){
+    const x=point.x-graphSurface.width/2,y=point.y-graphSurface.height/2;
+    graphCamera={scale,x:graphCamera.x+x*(before-scale),y:graphCamera.y+y*(before-scale)};
+  }else graphCamera.scale=scale;
+  boundCamera(graphSurface);drawGraph();syncGraphControls();
+}
 function rand(seed){return ()=>{seed=(Math.imul(seed,1664525)+1013904223)>>>0;return seed/4294967296;};}
 function hash(id){let value=2166136261;for(const char of id)value=Math.imul(value^char.charCodeAt(0),16777619);return value>>>0;}
 function mountGraph(){
   const canvas=$('brain-canvas'),stage=$('brain-stage');
   if(!canvas||canvas.hidden||!stage)return;
-  const ctx=canvas.getContext('2d');
-  if(!ctx)return;
-  const surface={canvas,stage,ctx,width:0,height:0,raf:0,observer:null,points:new Map(),edges:[],snapshot:undefined,counts:{}};
+  const ctx=canvas.getContext('2d'),layer=document.createElement('canvas'),layerContext=layer.getContext('2d');
+  if(!ctx||!layerContext)return;
+  const surface={canvas,stage,ctx,layer,layerContext,width:0,height:0,raf:0,observer:null,
+    points:new Map(),edges:[],snapshot:undefined,counts:{},drag:null,layerKey:''};
   graphSurface=surface;
   surface.observer=new ResizeObserver(()=>resizeGraph(surface));
   surface.observer.observe(stage);
   resizeGraph(surface);
   function hit(event){
     const box=canvas.getBoundingClientRect();
-    const x=event.clientX-box.left,y=event.clientY-box.top;
-    let best=null,distance=16;
+    const {x,y}=graphCoordinates(surface,event.clientX-box.left,event.clientY-box.top);
+    let best=null,distance=15/graphCamera.scale;
     for(const point of surface.points.values()){
       const d=Math.hypot(x-point.x,y-point.y);
       if(d<distance){best=point;distance=d;}
     }
     return best;
   }
+  canvas.addEventListener('pointerdown',event=>{
+    if(event.button!==0||event.pointerType==='touch'||graphCamera.scale===1)return;
+    surface.drag={id:event.pointerId,x:event.clientX,y:event.clientY,
+      fromX:graphCamera.x,fromY:graphCamera.y,moved:false};
+  });
   canvas.addEventListener('pointermove',event=>{
+    const drag=surface.drag;
+    if(drag?.id===event.pointerId){
+      const dx=event.clientX-drag.x,dy=event.clientY-drag.y;
+      if(drag.moved||Math.hypot(dx,dy)>4){
+        if(!drag.moved)canvas.setPointerCapture(event.pointerId);
+        drag.moved=true;graphCamera.x=drag.fromX+dx;graphCamera.y=drag.fromY+dy;
+        boundCamera(surface);canvas.style.cursor='grabbing';drawGraph();return;
+      }
+    }
     const point=hit(event);
-    canvas.style.cursor=point?'pointer':'default';
+    canvas.style.cursor=point?'pointer':graphCamera.scale>1?'grab':'default';
     const caption=$('node-caption');
     if(caption&&point){caption.hidden=false;caption.textContent=point.kind==='agent'?hostName(point.label):point.label;}
     else syncGraphControls();
   });
-  canvas.addEventListener('pointerleave',syncGraphControls);
-  canvas.addEventListener('click',event=>{const point=hit(event);if(point)void chooseMemory(point.id);});
+  canvas.addEventListener('pointerleave',()=>{if(!surface.drag?.moved)surface.drag=null;syncGraphControls();});
+  canvas.addEventListener('pointercancel',()=>{surface.drag=null;});
+  canvas.addEventListener('pointerup',event=>{
+    const moved=surface.drag?.moved;surface.drag=null;
+    canvas.style.cursor=graphCamera.scale>1?'grab':'default';
+    if(moved||event.button!==0)return;
+    const point=hit(event);
+    if(point)void chooseMemory(point.id);
+  });
+  syncGraphControls();
 }
 function unmountGraph(){
   if(!graphSurface)return;
@@ -44,55 +140,87 @@ function resizeGraph(surface){
   const {stage,canvas,ctx}=surface;
   const size=stage.getBoundingClientRect(),dpr=Math.min(devicePixelRatio,1.75);
   if(!size.width||!size.height)return;
-  surface.width=size.width;surface.height=size.height;surface.snapshot=undefined;
+  surface.width=size.width;surface.height=size.height;surface.snapshot=undefined;boundCamera(surface);
   canvas.width=Math.round(size.width*dpr);
   canvas.height=Math.round(size.height*dpr);
+  surface.layer.width=canvas.width;surface.layer.height=canvas.height;
+  surface.layerContext.setTransform(dpr,0,0,dpr,0,0);
+  surface.layerKey='';
   ctx.setTransform(dpr,0,0,dpr,0,0);
   drawGraph();
 }
-function brainFrame(width,height){return {x:width*.50,y:height*.51,rx:Math.min(width*.318,height*.76),ry:height*.42};}
-function drawOutline(ctx,{x,y,rx,ry}){
-  ctx.save();ctx.translate(x,y);ctx.rotate(-.19);ctx.scale(rx,ry);
-  ctx.beginPath();ctx.moveTo(0,-.82);
-  ctx.bezierCurveTo(-.26,-1.12,-.68,-.95,-.78,-.65);ctx.bezierCurveTo(-1.07,-.56,-1.14,-.11,-.97,.09);
-  ctx.bezierCurveTo(-1.09,.45,-.80,.80,-.57,.80);ctx.bezierCurveTo(-.39,1.03,-.11,.96,0,.83);
-  ctx.bezierCurveTo(.14,.97,.42,.94,.56,.76);ctx.bezierCurveTo(.89,.77,1.10,.48,.99,.16);
-  ctx.bezierCurveTo(1.15,-.09,1.07,-.44,.85,-.57);ctx.bezierCurveTo(.76,-.87,.31,-1.06,0,-.82);ctx.closePath();
-  ctx.restore();stroke(ctx,'119,157,206',.19,1);
+function brainFrame(width,height){return {x:width*.50,y:height*.49,rx:Math.min(width*.34,height*.70),ry:Math.min(height*.42,width*.255)};}
+function brainShell(angle){
+  const x=Math.cos(angle),y=Math.sin(angle);
+  const contour=1+.044*Math.cos(3*angle+.7)+.036*Math.cos(5*angle-.7)+.018*Math.sin(9*angle);
+  return {x:x*contour,y:y*contour*(y>0?.91+.12*x:1.02)-.07*x};
+}
+function brainProjection(frame,x,y,z){
+  const tilt=-.16,scale=1+.067*z;
+  const across=frame.rx*(x*scale+.10*z),down=frame.ry*(y*scale-.12*z);
+  return {x:frame.x+across*Math.cos(tilt)-down*Math.sin(tilt),y:frame.y+across*Math.sin(tilt)+down*Math.cos(tilt)};
+}
+function shellPath(ctx,frame,depth){
+  for(let step=0;step<=112;step++){
+    const rim=brainShell(step/112*Math.PI*2);
+    const point=brainProjection(frame,rim.x,rim.y,depth);
+    if(step===0)ctx.moveTo(point.x,point.y);
+    else ctx.lineTo(point.x,point.y);
+  }
+  ctx.closePath();
+}
+function drawOutline(ctx,frame){
+  const {x,y,rx,ry}=frame;
+  const field=ctx.createRadialGradient(x+rx*.22,y-ry*.42,0,x,y,rx*1.1);
+  field.addColorStop(0,'rgba(47,123,151,.22)');
+  field.addColorStop(.64,'rgba(52,74,132,.13)');
+  field.addColorStop(1,'rgba(15,24,47,.06)');
+  ctx.beginPath();shellPath(ctx,frame,0);ctx.fillStyle=field;ctx.fill();
+  ctx.beginPath();shellPath(ctx,frame,-.74);stroke(ctx,'108,162,215',.19,.7);
+  ctx.beginPath();shellPath(ctx,frame,.66);stroke(ctx,'140,193,225',.30,.9);
+  // Subtle contour guides give the point volume spatial context.
+  ctx.beginPath();
+  for(const [angle,depth] of [[-.76,-.22],[.38,.35],[1.24,.57]]){
+    const start=brainShell(angle),end=brainShell(angle+Math.PI);
+    const a=brainProjection(frame,start.x*.97,start.y*.97,depth);
+    const b=brainProjection(frame,-.28,.04,depth);
+    const c=brainProjection(frame,.45,-.22,depth);
+    const d=brainProjection(frame,end.x*.98,end.y*.98,depth);
+    ctx.moveTo(a.x,a.y);ctx.bezierCurveTo(c.x,c.y,b.x,b.y,d.x,d.y);
+  }
+  stroke(ctx,'135,181,233',.12,.75);
 }
 function graphPoints(width,height){
   const nodes=arr(state.graph?.nodes),anchors=nodes.filter(node=>node.kind!=='memory');
-  const memories=nodes.filter(node=>node.kind==='memory').sort((a,b)=>hash(a.id)-hash(b.id));
-  const {x:cx,y:cy,rx,ry}=brainFrame(width,height);
+  const memories=nodes.filter(node=>node.kind==='memory');
+  const frame=brainFrame(width,height);
   const points=new Map();
   function point(node,x,y,depth=1){points.set(node.id,{...node,x,y,depth});}
   for(const kind of ['project','agent']){
     const subset=anchors.filter(node=>node.kind===kind);
     subset.forEach((node,i)=>{
       const t=(i+1)/(subset.length+1),sign=kind==='project'?-1:1;
-      point(node,cx+sign*(rx*1.01+8*Math.sin(i*2.4)),height*.12+height*.75*t);
+      point(node,frame.x+sign*(frame.rx+Math.max(7,Math.min(32,width*.043))),height*.21+height*.58*t);
     });
   }
-  const golden=Math.PI*(3-Math.sqrt(5));
-  memories.forEach((node,i)=>{
-    const random=rand(hash(node.id)),side=i%2===0?-1:1;
-    const count=Math.ceil((memories.length-(i%2))/2),ordinal=Math.floor(i/2);
-    const angle=ordinal*golden+(side<0?.55:1.71)+(random()-.5)*.10;
-    const r=Math.sqrt((ordinal+.55)/count);
-    const x=side*.47+Math.cos(angle)*r*.45,y=Math.sin(angle)*r*.88;
-    const projectedX=x*.982+y*.19,projectedY=y*.982-x*.19;
-    point(node,cx+projectedX*rx,cy+projectedY*ry,.56+random()*.44);
-  });
+  const projected=memories.map(node=>{
+    const random=rand(hash(node.id));
+    const angle=random()*Math.PI*2,polar=random()*2-1;
+    const shell=random()<.40;
+    const radius=shell?.87+.13*random():Math.cbrt(random());
+    const rim=brainShell(angle),disk=Math.sqrt(1-polar**2)*radius,depth=polar*radius;
+    return {node,depth,...brainProjection(frame,rim.x*disk,rim.y*disk,depth)};
+  }).sort((left,right)=>left.depth-right.depth);
+  for(const node of projected)point(node.node,node.x,node.y,(node.depth+1)/2);
   return points;
 }
-function displayEvent(){return state.events.find(event=>event.id===state.replayId)??state.events.at(-1);}
+function displayEvent(){return state.replayId?state.events.find(event=>event.id===state.replayId):state.events.at(-1);}
 function graphEventPath(event,surface){
-  const {width,height,points}=surface;
-  const from=points.get('project:'+event.projectId),end=points.get('agent:'+event.agent);
-  if(!from||!end)return null;
-  const reverse=event.kind==='tool-start'||event.kind==='session-start';
-  return reverse?[end,{x:width*.51,y:height*.18},{x:width*.52,y:height*.69},from]:
-    [from,{x:width*.47,y:height*.73},{x:width*.49,y:height*.18},end];
+  if(!exchangeKey(event))return null;
+  const {width,height}=surface;
+  const workspace={x:width*.47,y:height*.67},client={x:width*.92,y:height*.37};
+  const controls=[{x:width*.31,y:height*.27},{x:width*.68,y:height*.16}];
+  return event.kind==='tool-start'?[client,...controls.reverse(),workspace]:[workspace,...controls,client];
 }
 function labelPoint(ctx,point,label,side,color,width,alpha){
   ctx.font='600 10.5px system-ui,sans-serif';
@@ -103,6 +231,46 @@ function labelPoint(ctx,point,label,side,color,width,alpha){
   ctx.globalAlpha=alpha;ctx.fillStyle='#111e31';ctx.beginPath();ctx.roundRect(x,y,labelWidth,18,3);ctx.fill();stroke(ctx,color,.43,.7);
   ctx.fillStyle='#ddefff';ctx.textAlign='left';ctx.textBaseline='middle';ctx.fillText(label,x+pad,y+9);ctx.globalAlpha=1;
 }
+function drawMemoryLayer(surface,current){
+  const {layerContext:ctx,width,height,points,edges}=surface;
+  const connected=new Set(current?[current]:[]);
+  if(current)for(const edge of edges){
+    if(edge.source===current)connected.add(edge.target);
+    if(edge.target===current)connected.add(edge.source);
+  }
+  ctx.clearRect(0,0,width,height);
+  ctx.save();ctx.translate(width/2+graphCamera.x,height/2+graphCamera.y);ctx.scale(graphCamera.scale,graphCamera.scale);ctx.translate(-width/2,-height/2);
+  if(points.size)drawOutline(ctx,brainFrame(width,height));
+  for(const edge of edges){
+    const relation=edge.kind==='belongs-to'?'project':edge.kind==='recorded-by'?'author':'typed';
+    if(state.graphFilter!=='all'&&relation!==state.graphFilter)continue;
+    const a=points.get(edge.source),b=points.get(edge.target);
+    const active=current&&(edge.source===current||edge.target===current);
+    const isTyped=relation==='typed',depth=(a.depth+b.depth)/2;
+    ctx.beginPath();ctx.moveTo(a.x,a.y);
+    if(isTyped)ctx.lineTo(b.x,b.y);
+    else ctx.quadraticCurveTo((a.x+b.x)/2,(a.y+b.y)/2+(a.x-b.x)*.08,b.x,b.y);
+    const color=relation==='project'?tones.project:relation==='author'?tones.agent:relationColors[edge.kind]??tones.memory;
+    if(active){stroke(ctx,color,.18,4);stroke(ctx,color,.88,1.25);}
+    else{
+      const alpha=isTyped?.10+depth*.38:state.graphFilter===relation?.16:.022;
+      stroke(ctx,color,current?alpha*.12:alpha,isTyped?.38+depth*.46:.57);
+    }
+  }
+  for(const point of points.values()){
+    const active=point.id===current,memory=point.kind==='memory';
+    const color=memory?(point.depth>.65?'145,230,247':tones.memory):tones[point.kind];
+    const alpha=(current&&!connected.has(point.id)?.23:1)*(.35+.65*point.depth);
+    const r=memory?(points.size>70?.68+1.12*point.depth:1.7+1.6*point.depth):3.4;
+    if(active||point.depth>.68)dot(ctx,point.x,point.y,active?12:r+2.4,color,.15*alpha);
+    dot(ctx,point.x,point.y,active?3.5:r,color,.88*alpha);
+    if(active||!memory){
+      ctx.beginPath();ctx.arc(point.x,point.y,active?8:5.4,0,Math.PI*2);stroke(ctx,color,.62*alpha,.75);
+    }
+    if(!memory&&width>510&&(active||surface.counts[point.kind]<=11))labelPoint(ctx,point,point.kind==='agent'?hostName(point.label):point.label,point.kind==='project'?-1:1,color,width,alpha);
+  }
+  ctx.restore();
+}
 function drawGraph(){
   const surface=graphSurface;
   if(!surface||!surface.width)return;
@@ -114,62 +282,56 @@ function drawGraph(){
     surface.edges=arr(state.graph?.edges).filter(edge=>surface.points.has(edge.source)&&surface.points.has(edge.target));
     surface.counts={};
     for(const point of surface.points.values())surface.counts[point.kind]=(surface.counts[point.kind]??0)+1;
+    surface.layerKey='';
   }
   const {points,edges}=surface;
   const current=state.focus?state.picked:null;
-  const connected=new Set(current?[current]:[]);
-  if(current)for(const edge of edges){
-    if(edge.source===current)connected.add(edge.target);
-    if(edge.target===current)connected.add(edge.source);
-  }
+  const layerKey=JSON.stringify([current,state.graphFilter,graphCamera]);
+  if(surface.layerKey!==layerKey){drawMemoryLayer(surface,current);surface.layerKey=layerKey;}
   ctx.clearRect(0,0,width,height);
-  if(points.size)drawOutline(ctx,brainFrame(width,height));
-  for(const edge of edges){
-    const a=points.get(edge.source),b=points.get(edge.target);
-    const active=current&&(edge.source===current||edge.target===current);
-    ctx.beginPath();ctx.moveTo(a.x,a.y);ctx.quadraticCurveTo((a.x+b.x)/2,(a.y+b.y)/2+(a.x-b.x)*.15,b.x,b.y);
-    const color=edge.kind==='belongs-to'?tones.project:edge.kind==='recorded-by'?tones.agent:'241,200,138';
-    if(active){stroke(ctx,color,.22,4.5);stroke(ctx,color,.96,1.45);}
-    else stroke(ctx,color,current?.08:edge.kind==='recorded-by'?.46:.52,.84);
-  }
-  for(const point of points.values()){
-    const active=point.id===current,color=tones[point.kind]??tones.memory;
-    const alpha=(current&&!connected.has(point.id)?.31:1)*point.depth;
-    const r=point.kind==='memory'?(points.size>70?2.8:4.1):5.2;
-    dot(ctx,point.x,point.y,active?15:r+5,color,.13*alpha);
-    dot(ctx,point.x,point.y,active?4.5:r,color,.92*alpha);
-    if(active||point.kind!=='memory'){
-      ctx.beginPath();ctx.arc(point.x,point.y,active?10:8,0,Math.PI*2);stroke(ctx,color,.68*alpha,.9);
-    }
-    if(point.kind!=='memory'&&width>510&&(active||surface.counts[point.kind]<=11))labelPoint(ctx,point,point.kind==='agent'?hostName(point.label):point.label,point.kind==='project'?-1:1,color,width,alpha);
-  }
+  ctx.drawImage(surface.layer,0,0,width,height);
   const age=performance.now()-state.motionStarted;
-  const animate=!document.hidden&&!reduced.matches&&!state.motionPaused&&!state.replayId&&state.live&&state.connection==='reachable'&&state.pulseIds.length&&age<1500;
-  const traceEvents=current?[]:animate?state.events.filter(event=>state.pulseIds.includes(event.id)):
+  const animate=!document.hidden&&!reduced.matches&&!state.motionPaused&&!state.replayId&&state.live&&state.connection==='reachable'&&state.pulseIds.length&&age<1350&&!state.listing;
+  const traceEvents=animate?state.events.filter(event=>state.pulseIds.includes(event.id)&&exchangeKey(event)):
     state.replayId?[displayEvent()].filter(Boolean):[];
-  const routes=traceEvents.map(event=>({event,path:graphEventPath(event,surface)})).filter(route=>route.path);
-  routes.forEach(({event,path},index)=>{
-    const [a,b,c,d]=path,color=tones[event.source]??tones.reported;
+  // The lower lane represents MCP boundary activity independently of the stored graph.
+  const step=animate?age/1350*traceEvents.length:0;
+  const currentEvent=traceEvents[Math.floor(step)];
+  const path=currentEvent&&graphEventPath(currentEvent,surface);
+  if(path){
+    const event=currentEvent;
+    const [a,b,c,d]=path,color=event.kind==='tool-start'?'104,205,238':event.outcome==='success'?tones.measured:'255,172,182';
+    const direction=Math.atan2(d.y-c.y,d.x-c.x);
     ctx.beginPath();ctx.moveTo(a.x,a.y);ctx.bezierCurveTo(b.x,b.y,c.x,c.y,d.x,d.y);
-    stroke(ctx,color,.19,4.2);stroke(ctx,color,.81,1.25);
-    const t=animate?Math.max(0,Math.min(1,age/1310-index*.055)):.58,u=1-t;
+    stroke(ctx,color,.10,7);stroke(ctx,color,.24,3.2);stroke(ctx,color,.88,1.35);
+    ctx.save();ctx.translate(d.x,d.y);ctx.rotate(direction);
+    ctx.beginPath();ctx.moveTo(-6,-3.1);ctx.lineTo(0,0);ctx.lineTo(-6,3.1);stroke(ctx,color,.92,1.3);ctx.restore();
+    const t=animate?step%1:.58,u=1-t;
     const x=u**3*a.x+3*u*u*t*b.x+3*u*t*t*c.x+t**3*d.x;
     const y=u**3*a.y+3*u*u*t*b.y+3*u*t*t*c.y+t**3*d.y;
     dot(ctx,x,y,8,color,.19);dot(ctx,x,y,4,color,.52);dot(ctx,x,y,1.9,'237,255,255',1);
-  });
+  }
   const graphEvent=$('graph-event');
   if(graphEvent){
-    const event=traceEvents.at(-1),text=event?evidence(event)+' · '+hostName(event.agent)+(routes.length?'':' · journal only'):'';
+    const text=path?exchangeDirection(currentEvent)+' · '+exchangeLabel(currentEvent):'';
     if(graphEvent.textContent!==text)graphEvent.textContent=text;
+    graphEvent.hidden=!path||!!current||state.listing;
   }
   canvas.dataset.nodes=String(points.size);canvas.dataset.edges=String(edges.length);
-  canvas.dataset.pulses=String(routes.length);canvas.dataset.frame=animate&&routes.length?String(Math.round(age)):'static';
-  if(animate&&routes.length)surface.raf=requestAnimationFrame(drawGraph);
+  canvas.dataset.pulses=path?'1':'0';canvas.dataset.frame=animate&&path?String(Math.round(age)):'static';
+  if(animate&&path)surface.raf=requestAnimationFrame(drawGraph);
 }
 function syncGraphControls(){
   const label=$('node-caption'),point=arr(state.graph?.nodes).find(node=>node.id===state.picked);
   if(label){label.hidden=!state.focus||!point||state.listing;label.textContent=point?.label??'';}
   const clear=$('clear-focus');if(clear)clear.hidden=!state.focus;
+  const zoom=$('graph-zoom');
+  if(zoom)zoom.textContent=Math.round(graphCamera.scale*100)+'%';
+  const plus=$('graph-zoom-in'),minus=$('graph-zoom-out');
+  // Keep zoom controls focusable at bounds for keyboard continuity.
+  plus?.setAttribute('aria-disabled',String(graphCamera.scale>=3));
+  minus?.setAttribute('aria-disabled',String(graphCamera.scale<=1));
+  $('main').querySelectorAll('[data-graph-filter]').forEach(button=>button.setAttribute('aria-pressed',String(state.graphFilter===button.dataset.graphFilter)));
   $('brain-stage')?.querySelectorAll('[data-node]').forEach(button=>button.setAttribute('aria-pressed',String(button.dataset.node===state.picked&&state.focus)));
 }
 `;

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"brain-hub-html.d.ts","sourceRoot":"","sources":["../../src/dashboard/brain-hub-html.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,QAyBH,CAAC"}
+{"version":3,"file":"brain-hub-html.d.ts","sourceRoot":"","sources":["../../src/dashboard/brain-hub-html.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc,QA8EH,CAAC"}

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

@@ -1,5 +1,7 @@
 import { BRAIN_HUB_CLIENT } from './brain-hub-client.js';
 import { BRAIN_HUB_GRAPH } from './brain-hub-graph.js';
+import { BRAIN_HUB_EXCHANGES } from './brain-hub-exchanges.js';
+import { BRAIN_HUB_LIVE } from './brain-hub-live.js';
 import { BRAIN_HUB_VIEWS } from './brain-hub-views.js';
 export const BRAIN_HUB_HTML = String.raw `<!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>Agent Shadow Brain</title>
@@ -15,16 +17,69 @@ export const BRAIN_HUB_HTML = String.raw `<!doctype html>
 @media(max-width:980px){.control-grid{grid-template-columns:145px minmax(0,1fr)}.control-grid>.inspect{grid-column:1/-1}.three{grid-template-columns:minmax(145px,.6fr) minmax(0,1.4fr)}.three>.panel:last-child{grid-column:1/-1}}
 @media(max-width:680px){.frame{padding-inline:10px}.top,.page-head{flex-wrap:wrap}.top .actions{width:100%}.nav{margin-bottom:10px}.strip{grid-template-columns:repeat(2,minmax(0,1fr))}.metric:nth-child(3){border-left:0}.metric:nth-child(n+3){border-top:1px solid var(--border)}.control-grid,.lower,.two,.three{grid-template-columns:minmax(0,1fr)}.graph-panel{grid-row:1}.graph-stage{min-height:320px}.control-grid>.rail{max-height:240px}.event{grid-template-columns:61px minmax(0,1fr)}.event .chip{justify-self:start;grid-column:2}.graph-meta{font-size:.62rem}h1{font-size:1.65rem}}
 @media(prefers-reduced-motion:reduce){*,*::before,*::after{animation:none!important;transition:none!important}}
+.sr-only{position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%);white-space:nowrap}
+.graph-panel{background:var(--surface)}.graph-stage{background:radial-gradient(circle,#6a84a128 .6px,transparent .9px) 0 0/18px 18px,radial-gradient(ellipse at 50% 55%,#12243b,#0b1527 62%,#080f1c 100%)}
+.graph-meta{font-size:.73rem;color:#bdd0e6;text-transform:none}.graph-foot{padding-block:4px;gap:3px 8px}
+.legend,.graph-camera{display:flex;align-items:center;flex-wrap:wrap;gap:3px}.legend .legend-filter{display:inline-flex;gap:5px;align-items:center;padding:3px 6px;min-height:27px;border:1px solid transparent;border-radius:4px;background:transparent;color:var(--muted)}
+.legend .legend-filter[aria-pressed=true]{border-color:var(--strong);background:var(--raised);color:var(--ink)}
+.legend .legend-filter:hover{color:var(--ink);background:var(--raised)}.legend .legend-filter i{width:10px}
+.graph-camera .btn{font-size:.73rem;min-height:26px;padding:2px 7px}.graph-camera .btn[aria-disabled=true]{opacity:.55;cursor:default}.graph-camera output{width:4ch;text-align:center}
+.graph-finder{display:flex;flex-direction:column;border-radius:5px;overflow:hidden;background:#0d182b}
+.graph-find{display:flex;align-items:center;gap:6px;flex-wrap:wrap;padding:8px;border-bottom:1px solid var(--border);background:var(--surface)}
+.graph-find input{flex:1;min-width:130px}.graph-results{overflow:auto;flex:1}.graph-search-note{padding:6px 9px}
+.graph-exchanges{border-top:1px solid var(--border);background:var(--surface)}
+.exchange-head{display:flex;align-items:center;justify-content:space-between;gap:8px;padding:5px 9px}
+.exchange-head h3{font-size:.84rem;font-weight:650;letter-spacing:0}
+.exchange-row{display:grid;width:100%;grid-template-columns:minmax(110px,1.2fr) minmax(96px,1fr) auto;gap:4px 8px;align-items:center;text-align:left;border:0;border-top:1px solid var(--border);background:transparent;color:var(--ink);padding:4px 9px;font-size:.76rem}
+.exchange-row:hover,.exchange-row[aria-pressed=true]{background:var(--raised)}
+.exchange-row:focus-visible{outline-offset:-2px}
+.exchange-route,.exchange-summary{display:flex;align-items:center;gap:5px;min-width:0}
+.exchange-route span:not(.exchange-arrow),.exchange-summary strong{min-width:0;overflow-wrap:anywhere}
+.exchange-route .exchange-workspace{flex:none;white-space:nowrap}
+.exchange-route small{display:inline-block}
+.exchange-summary{color:var(--muted);flex-wrap:wrap}.exchange-summary strong{font:600 .76rem var(--mono);color:var(--ink)}
+.exchange-arrow{position:relative;flex:0 0 18px;height:1px;background:var(--cyan)}
+.exchange-arrow::after{content:"";position:absolute;right:0;top:-2px;width:5px;height:5px;transform:rotate(45deg);border-top:1px solid var(--cyan);border-right:1px solid var(--cyan)}
+.exchange-empty{padding:0 9px 7px}
+.live-path-label{position:absolute;bottom:3px;left:50%;transform:translateX(-50%);max-width:92%;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;padding:2px 6px;border-radius:4px;background:var(--ground);color:var(--ink);font-size:.73rem;pointer-events:none}
+@media(min-width:981px){.control-grid{grid-template-rows:576px}}
+@media(max-width:680px){.legend .legend-filter,.graph-camera .btn{min-height:36px}.exchange-row{min-height:40px;padding-block:6px}.graph-panel-empty .graph-stage{min-height:220px}}
+@media(max-width:360px){.exchange-row{grid-template-columns:minmax(0,1fr) minmax(0,1fr)}.exchange-row time{grid-column:1/-1}.graph-find input{flex-basis:100%}}
+.preserve{white-space:pre-wrap;overflow-wrap:anywhere}
+.tool-dock{margin-bottom:10px}.tool-dock-head{display:flex;align-items:baseline;justify-content:space-between;gap:4px 12px;flex-wrap:wrap;padding:9px 12px}
+.tool-dock-list{display:flex;align-items:stretch;gap:6px;flex-wrap:wrap;padding:0 12px 8px}
+.tool-dock-list>li+li{border:0}.tool-dock-button{display:flex;align-items:center;gap:8px;min-height:42px;padding:5px 10px;border:1px solid var(--border);
+  border-radius:6px;color:var(--ink);background:var(--raised);text-align:left}
+.tool-dock-button:hover,.tool-dock-button[aria-expanded=true]{border-color:var(--cyan)}
+.tool-mark{width:23px;height:23px;display:grid;place-items:center;color:var(--ink);font:700 .72rem var(--mono)}
+.tool-mark svg{display:block;width:100%;height:100%}
+.tool-dock-text{display:grid;gap:1px;line-height:1.2}.tool-dock-text strong{font-size:.81rem}.tool-dock-text small{color:var(--muted);font-size:.69rem}
+.tool-dock-indicator{width:6px;height:6px;margin-left:4px;border-radius:50%;background:var(--strong)}
+.tool-activity-pulse{animation:tool-report 1.3s ease-out}
+@keyframes tool-report{0%{background:var(--cyan);box-shadow:0 0 0 5px #78e9e53d}100%{background:var(--strong);box-shadow:0 0 0 0 #78e9e500}}
+.tool-dock-empty,.tool-dock-caption{padding:0 12px 7px}.tool-dock-details{display:grid;gap:5px;padding:9px 12px;border-top:1px solid var(--border);background:var(--ground)}
+.tool-dock-record-list{display:flex;flex-wrap:wrap;gap:6px}.tool-dock-record-list>li+li{border:0}
+.tool-dock-record-list li{max-width:100%}.tool-dock-record{display:grid;gap:1px;min-height:36px;padding:4px 7px;color:var(--ink);background:var(--surface);border:1px solid var(--border);border-radius:5px;text-align:left;overflow-wrap:anywhere;font-size:.76rem}
+.tool-dock-record[aria-pressed=true],.tool-dock-record:hover{border-color:var(--cyan)}
+.tool-evidence-grid{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:12px}.tool-evidence-grid dt,.tool-evidence-grid dd{overflow-wrap:anywhere}
+@media(max-width:680px){.tool-evidence-grid{grid-template-columns:minmax(0,1fr)}.tool-dock-button,.tool-dock-record{min-height:44px}}
+@media(prefers-reduced-motion:reduce){.tool-activity-pulse{animation:none}}
+[id^="policy-"][type="range"]{accent-color:var(--cyan)}
+#project-file-body strong{min-width:0;overflow-wrap:anywhere}
+#project-file-pulse{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--muted)}
+.file-fresh{animation:file-observed 1.6s ease-out}
+@keyframes file-observed{0%{color:var(--cyan)}100%{color:var(--muted)}}
 </style></head><body>
 <a class="btn skip" href="#main">Skip to content</a>
 <div class="frame"><header class="top"><div class="brand"><svg viewBox="0 0 32 32" aria-hidden="true"><path d="M16 2 28 9v14l-12 7-12-7V9Zm0 0v28M4 9l24 14M28 9 4 23" fill="none" stroke="currentColor" stroke-width="1.4"/><circle cx="16" cy="16" r="3.3" fill="currentColor"/></svg>Agent Shadow Brain</div><div class="actions"><span class="chip" id="connection"><i class="dot" aria-hidden="true"></i> Connecting to workspace</span><label for="project" class="small muted">Project</label><select id="project" disabled><option>Loading…</option></select><button class="btn" id="reload" type="button">Refresh</button></div></header>
 <nav class="nav" id="nav" aria-label="Brain workspace"></nav>
+<span class="chip" id="stream-health" role="status" hidden></span>
 <p class="notice" id="notice" role="status"></p>
 <main id="main" tabindex="-1"><div class="empty"><strong>Opening the workspace</strong><p>Loading the local memory and activity stores.</p></div></main>
 <footer class="footer"><span id="scope-note"></span><span><a href="/workspace">Classic workspace</a> · <a href="/live">Activity diagnostics</a></span></footer>
 </div>
 <script>'use strict';
-` + BRAIN_HUB_CLIENT + BRAIN_HUB_GRAPH + BRAIN_HUB_VIEWS + String.raw `
+` + BRAIN_HUB_CLIENT + BRAIN_HUB_LIVE + BRAIN_HUB_EXCHANGES + BRAIN_HUB_GRAPH + BRAIN_HUB_VIEWS + String.raw `
 start();
 </script></body></html>`;
 //# sourceMappingURL=brain-hub-html.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"brain-hub-html.js","sourceRoot":"","sources":["../../src/dashboard/brain-hub-html.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;CAuBvC,GAAG,gBAAgB,GAAG,eAAe,GAAG,eAAe,GAAG,MAAM,CAAC,GAAG,CAAA;;wBAE7C,CAAC"}
+{"version":3,"file":"brain-hub-html.js","sourceRoot":"","sources":["../../src/dashboard/brain-hub-html.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4EvC,GAAG,gBAAgB,GAAG,cAAc,GAAG,mBAAmB,GAAG,eAAe,GAAG,eAAe,GAAG,MAAM,CAAC,GAAG,CAAA;;wBAEpF,CAAC"}

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

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

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

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

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

@@ -0,0 +1,33 @@
+export const BRAIN_HUB_KNOWLEDGE = String.raw `
+function sourceReview(){
+  const source=state.source;
+  if(!source)return empty('Your saved notes and review','Paste ordinary text and choose Add to memory. For longer notes, choose Review first and save the useful parts.');
+  const counts={pending:0,approved:0,rejected:0};arr(source.items).forEach(item=>counts[item.status]++);
+  return '<div class="panel-body stack"><div class="row"><h3>'+esc(source.title)+'</h3>'+chip(source.kind)+'</div><p class="small muted">'+counts.pending+' to review · '+counts.approved+' saved · '+counts.rejected+' skipped. Titles and categories are suggestions from the text’s structure; check them before saving.</p>'+list(arr(source.items).map(item=>{
+    const chosen=item.approved??item;
+    return '<li class="item"><div class="row"><strong>'+esc(chosen.title)+'</strong>'+chip(item.status,item.status==='approved'?'green':'amber')+'</div><p class="small mono muted">'+esc(item.id)+(item.role?' · Speaker: '+esc(item.role):'')+'</p>'+
+      (item.status==='pending'?'<form class="form" data-form="source-review" data-item="'+esc(item.id)+'"><label>Name for this memory<input name="title" maxlength="150" value="'+esc(item.title)+'" required></label><label>What the brain should remember<textarea name="text" rows="4" maxlength="6000" required>'+esc(item.text)+'</textarea></label><label>Topic<input name="category" maxlength="64" value="'+esc(item.category)+'" required></label><div class="actions"><button class="btn primary" type="submit" name="decision" value="approve" '+(state.pending?'disabled':'')+'>Save to this project</button><button class="btn" type="submit" name="decision" value="reject" formnovalidate '+(state.pending?'disabled':'')+'>Skip this part</button></div></form>':'<p class="preserve">'+esc(chosen.text)+'</p>'+ (item.memoryId?'<div class="actions">'+action('open-memory','Inspect memory','','data-memory="'+esc(item.memoryId)+'"')+action('source-evidence','View original source','','data-memory="'+esc(item.memoryId)+'"')+'</div>':''));
+  }).join(''))+(source.kind==='transcript-json'&&counts.approved?'<p class="small muted">Finish reviewing first: the session will contain a snapshot of the messages approved now. Reimporting opens the same snapshot.</p>'+action('import-session','Open reviewed history in Sessions'):'')+'<details><summary>Original source fingerprint</summary><pre>'+esc(source.sha256)+'</pre><p class="small muted">'+esc(source.name)+' · '+fmt(source.bytes)+' bytes · '+esc(source.parser)+'</p></details></div>';
+}
+function teachPanel(){
+  return panel('Add to memory','<div class="panel-body stack"><p>Write what you want your agents to remember. Ordinary words are enough.</p><form class="form" data-form="teach"><label>What should this project remember?<textarea name="text" rows="7" maxlength="180000" placeholder="The cupboard is black. Keep its brass handles when we redesign the room." required>'+esc(state.teachDraft??'')+'</textarea></label><div class="actions"><button class="btn primary" type="submit" name="mode" value="save" '+(state.pending?'disabled':'')+'>Add to memory</button><button class="btn" type="submit" name="mode" value="review" '+(state.pending?'disabled':'')+'>Review first</button></div></form><p class="small muted">Add to memory saves your text as reference knowledge for connected agents in this project. Try “What colour is the cupboard?” in Context to check recall. Notes up to 6,000 characters and 20 paragraphs can be saved directly; use Review first for longer notes or corrections.</p><details><summary>Optional: upload text, Markdown, or a conversation</summary><form class="form" data-form="source-upload"><label>Source file<input name="source" type="file" accept=".txt,.md,.markdown,.json,text/plain,application/json" required></label><p class="small muted">Up to 1 MiB. Conversations use a simple JSON messages array with role and text content. Imported messages remain reference material, including messages labelled system or developer.</p><p class="small muted">Download a sample to see the supported JSON formats:</p><div class="actions">'+action('download-example','Knowledge JSON','','data-example="knowledge"')+action('download-example','Transcript JSON','','data-example="transcript"')+action('download-example','Simple transcript JSON','','data-example="simple"')+'</div>'+submit('Review file')+'</form></details></div>');
+}
+function evidencePanel(){
+  const result=state.evidence;if(!result)return '';
+  const e=result.evidence;
+  return panel('Original source','<div class="panel-body stack"><div class="row">'+chip(result.state,result.state==='resolved'?'green':'amber')+action('close-evidence','Close')+'</div>'+(e?'<h3>'+esc(e.title)+'</h3><p class="small mono">'+esc([e.kind,e.page?'Page '+e.page:e.locator,e.role?'Speaker: '+e.role:''].filter(Boolean).join(' · '))+'</p><pre>'+esc(e.text)+'</pre>'+(e.truncated?'<p class="small amber">This display is a bounded excerpt.</p>':'')+(e.approvedText!==undefined&&e.approvedText!==e.text?'<h3>Your approved correction</h3><pre>'+esc(e.approvedText)+'</pre>':'')+(e.outcome?'<h3>Reported outcome</h3><p>'+esc(e.outcome.result)+' - '+esc(e.outcome.check)+' - '+esc(e.outcome.provenance)+'</p><pre>'+esc(e.outcome.evidence)+'</pre>':'')+(e.evaluation?'<h3>Operator-reported comparison</h3><p>Baseline: '+(e.evaluation.baseline?'pass':'fail')+' - Candidate: '+(e.evaluation.candidate?'pass':'fail')+' - Control: '+(e.evaluation.control?'pass':'fail')+'</p><pre>'+esc(e.evaluation.evidence)+'</pre>':'')+(e.sha256?'<details><summary>Verified stored fingerprint</summary><pre>'+esc(e.sha256)+'</pre></details>':'')+'<p class="small muted">Source association checked against this project. '+(e.reported?'Evaluation results were reported by an operator.':'This verifies where the text came from, not whether every claim is true.')+'</p>':'<p>'+esc(result.state==='reference-only'?'This memory has a reference label, without a stored source to verify.':'The original source could not be verified. No unrelated file was opened.')+'</p>')+'</div>');
+}
+function sourceLibrary(){
+  if(state.errors.sources)return error('sources','saved sources');
+  const sources=arr(state.sources?.sources);
+  return sources.length?list(sources.map(source=>'<li><button class="entry" type="button" data-source="'+esc(source.id)+'" aria-pressed="'+(source.id===state.source?.id)+'"><strong>'+esc(source.title)+'</strong><small class="muted">'+esc(source.kind)+' · '+source.approvedCount+' saved / '+source.itemCount+' parts</small></button></li>').join('')):empty('Your source library is empty','Notes and uploaded files stay in this project.');
+}
+function feedbackControls(){
+  const feedback=state.feedback;
+  if(!feedback)return error('feedback','learning feedback')||empty('Loading learning history','Reading feedback for this project.');
+  const memories=arr(state.context?.entries);
+  const choices=memories.length?memories:arr(state.graph?.nodes).filter(node=>node.kind==='memory').map(node=>({id:node.memoryId,excerpt:node.label}));
+  return '<div class="panel-body stack"><p>Tell the brain what helped for a task. Useful memories can rank higher for similar work; incorrect memories receive a penalty. Feedback changes retrieval, not model weights.</p><div class="actions">'+chip(feedback.enabled?'Feedback influences recall':'Feedback influence paused',feedback.enabled?'green':'amber')+action('toggle-feedback',feedback.enabled?'Pause influence':'Enable influence')+'</div>'+(choices.length?'<form class="form" data-form="feedback"><label>Memory<select name="memoryId">'+choices.map(entry=>'<option value="'+esc(entry.id)+'">'+esc(entry.excerpt)+'</option>').join('')+'</select></label><label>What were you working on?<input name="task" maxlength="1000" value="'+esc(state.contextInput?.query??'')+'" required></label><label>Was the memory helpful?<select name="rating"><option value="useful">Useful</option><option value="not-useful">Not relevant to this task</option><option value="incorrect">Incorrect</option></select></label><label>Why?<textarea name="reason" rows="2" maxlength="600" required></textarea></label>'+submit('Save feedback')+'</form>':empty('Start with a context pack','Describe a task in Context, then review the memories it selected.',view('context','Try a task')))+list(arr(feedback.records).slice().reverse().map(record=>'<li class="item"><div class="row"><strong>'+esc(record.rating)+'</strong>'+action('remove-feedback','Remove','','data-feedback="'+esc(record.id)+'"')+'</div><p>'+esc(record.task)+'</p><p class="small muted">'+esc(record.reason)+'</p>'+action('open-memory','Inspect memory','','data-memory="'+esc(record.memoryId)+'"')+'</li>').join(''))+'</div>';
+}
+`;
+//# sourceMappingURL=brain-hub-knowledge.js.map

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

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

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

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

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

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