@theihtisham/agent-shadow-brain 7.2.0 → 7.22.0

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"}

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

@@ -0,0 +1,151 @@
+export const BRAIN_HUB_LIVE = String.raw `
+const liveStream={source:null,status:'connecting',cursor:null,instance:null,replaying:false,ready:false,notice:null,areas:new Set(),
+  timer:0,files:null,fileError:null,fileEpoch:0,inventoryTimer:0,seen:new Map(),filePulse:null};
+const streamAreas=['telemetry','graph','hub','sources','sessions','usage','features','feedback','policy','presence'];
+function streamBadge(){
+  const badge=$('stream-health');
+  if(!badge||!local)return;
+  const state=liveStream.status;
+  badge.hidden=false;
+  badge.className='chip '+(state==='live'?'green':state==='fallback'?'amber':'');
+  badge.textContent=state==='live'?'Live stream':state==='fallback'?'Polling fallback':state==='off'?'Live updates off':'Connecting stream';
+}
+function queueLive(areas){
+  for(const area of areas)if(streamAreas.includes(area))liveStream.areas.add(area);
+  if(liveStream.timer||!liveStream.areas.size)return;
+  liveStream.timer=setTimeout(()=>{
+    liveStream.timer=0;
+    if(document.hidden)return;
+    if(polling||state.pending){queueLive([]);return;}
+    const areas=new Set(liveStream.areas);
+    liveStream.areas.clear();
+    void refresh(false,areas);
+  },55);
+}
+function clearLiveFiles(){
+  liveStream.files=null;liveStream.fileError=null;liveStream.filePulse=null;liveStream.seen.clear();liveStream.fileEpoch++;
+  updateLiveFilePanel();updateLiveFilePulse();
+}
+function stopProjectStream(){
+  liveStream.source?.close();liveStream.source=null;
+  liveStream.ready=false;liveStream.replaying=false;
+  clearTimeout(liveStream.timer);liveStream.timer=0;clearTimeout(liveStream.inventoryTimer);liveStream.inventoryTimer=0;
+  liveStream.areas.clear();
+}
+function syncProjectStream(){
+  if(!local||document.hidden||!state.server?.capabilities?.liveStream)return;
+  if(state.features?.features?.liveActivity===false){
+    stopProjectStream();clearLiveFiles();liveStream.cursor=null;liveStream.status='off';streamBadge();return;
+  }
+  if(liveStream.source)return;
+  if(typeof EventSource!=='function'){liveStream.status='fallback';streamBadge();return;}
+  liveStream.status='connecting';streamBadge();
+  const previous=liveStream.cursor;
+  liveStream.replaying=!!previous;
+  const source=new EventSource('/api/workspace/stream'+(previous?'?'+new URLSearchParams({cursor:previous}):''));
+  liveStream.source=source;
+  function handle(message){
+    if(liveStream.source!==source)return;
+    let data;
+    try{data=JSON.parse(message.data);}catch{return;}
+    if(!data||typeof data.serverInstanceId!=='string'||!Number.isSafeInteger(data.sequence)||data.kind!==message.type)return;
+    if(liveStream.instance&&liveStream.instance!==data.serverInstanceId)clearLiveFiles();
+    liveStream.instance=data.serverInstanceId;
+    liveStream.cursor=message.lastEventId;
+    if(data.kind==='disabled'){
+      stopProjectStream();clearLiveFiles();liveStream.cursor=null;liveStream.status='off';streamBadge();
+      void refresh(true);return;
+    }
+    if(data.kind==='reset'){
+      liveStream.notice='Live history changed. The workspace refreshed its current snapshot.';
+      clearLiveFiles();return;
+    }
+    if(data.kind==='ready'){
+      const reconnect=liveStream.replaying||liveStream.ready;
+      liveStream.status='live';liveStream.ready=true;liveStream.replaying=false;
+      if(!pollAgain)clearTimeout(timer);
+      streamBadge();
+      if(reconnect){state.suppressLivePulse=true;void refresh(true);}
+      else queueLive(streamAreas);
+      if(data.watch?.status!=='off')void readLiveFiles();
+      renderChrome();return;
+    }
+    if(data.kind==='change'){if(liveStream.ready&&!liveStream.replaying)queueLive(arr(data.areas));return;}
+    if(data.kind==='watch'){void readLiveFiles();return;}
+    if(data.kind==='file'&&typeof data.path==='string'&&data.path.length<=320){
+      if(liveStream.seen.has(data.sequence))return;
+      liveStream.seen.set(data.sequence,data);
+      if(liveStream.seen.size>50)liveStream.seen.delete(liveStream.seen.keys().next().value);
+      if(liveStream.ready&&!liveStream.replaying&&state.view==='overview'){
+        liveStream.filePulse=data;updateLiveFilePulse(!reduced.matches&&!state.motionPaused&&!state.replayId);
+      }
+      updateLiveFilePanel();
+      clearTimeout(liveStream.inventoryTimer);
+      liveStream.inventoryTimer=setTimeout(()=>void readLiveFiles(),240);
+    }
+  }
+  for(const kind of ['ready','change','file','watch','reset','disabled'])source.addEventListener(kind,handle);
+  source.addEventListener('error',()=>{
+    if(liveStream.source!==source)return;
+    liveStream.status='fallback';liveStream.replaying=true;streamBadge();
+    if(!polling)void refresh();
+  });
+}
+async function readLiveFiles(){
+  if(!local||document.hidden||state.features?.features?.liveActivity===false)return;
+  const id=++liveStream.fileEpoch;
+  try{
+    const files=await api('project-files');
+    if(id!==liveStream.fileEpoch)return;
+    if(liveStream.instance&&liveStream.instance!==files.serverInstanceId)liveStream.seen.clear();
+    liveStream.files=files;liveStream.fileError=null;
+    if(!files.enabled||files.watch?.status==='off'){liveStream.filePulse=null;liveStream.seen.clear();updateLiveFilePulse();}
+    for(const event of arr(files.events))if(!liveStream.seen.has(event.sequence))liveStream.seen.set(event.sequence,event);
+    const sequences=[...liveStream.seen.keys()].sort((a,b)=>a-b).slice(0,-50);
+    for(const sequence of sequences)liveStream.seen.delete(sequence);
+  }catch(failure){if(id===liveStream.fileEpoch)liveStream.fileError=failure.message;}
+  updateLiveFilePanel();
+}
+function liveFileBody(){
+  const fileFeature=state.features?.features?.projectFileActivity??liveStream.files?.enabled;
+  if(!fileFeature)return empty('Project file activity is off','Enable it in Setup to observe safe relative paths in this project.',view('setup','Open Setup'));
+  if(liveStream.status==='off')return empty('Live updates are off','Enable live dashboard activity in Setup.',view('setup','Open Setup'));
+  if(state.features?.features?.activityRecording===false)return empty('Activity recording is off','Enable activity recording in Setup to observe file changes.',view('setup','Open Setup'));
+  const watch=liveStream.files?.watch;
+  const known=arr(liveStream.files?.items);
+  const summary=watch?.status==='limited'?'Watch coverage is limited. Some paths may be omitted.':
+    watch?.status==='watching'?fmt(watch.directories)+' watched directories':watch?.status==='off'?'Waiting for a live subscription.':'Opening the selected project.';
+  const received=[...liveStream.seen.values()].sort((a,b)=>b.sequence-a.sequence).slice(0,24);
+  const entries=received.map(event=>'<li class="item"><div class="row"><strong class="mono">'+esc(event.path)+'</strong><time class="small mono muted" datetime="'+esc(event.timestamp)+'">'+esc(time(event.timestamp))+'</time></div><small class="muted">'+
+    esc(event.operation==='entry'?(event.exists?'Directory entry changed':'Removed or renamed'):'Change notification')+
+    ' · Unknown actor'+(event.count>1?' · '+fmt(event.count)+' grouped notifications':'')+'</small></li>').join('');
+  const mostRecent=received[0]?' · Last observed '+time(received[0].timestamp):'';
+  return '<div class="panel-body stack"><p class="small muted">'+esc(liveStream.fileError??(summary+mostRecent))+'</p>'+
+    (entries?list(entries,'aria-label="Observed project file changes"'):'<p class="small muted">No eligible changes have been observed.</p>')+
+    (known.length?'<details><summary>Project paths · '+fmt(known.length)+(watch?.inventoryLimited?' shown':'')+'</summary>'+list(known.map(item=>'<li class="item small mono">'+esc(item.path)+(item.entry==='directory'?'/':'')+'</li>').join(''))+'</details>':'')+'</div>';
+}
+function liveFilePanel(){
+  return '<section class="panel" aria-label="Project file activity"><div class="panel-head"><h2>Project file activity</h2></div><div id="project-file-body">'+liveFileBody()+'</div></section>';
+}
+function updateLiveFilePanel(){
+  const region=$('project-file-body');
+  if(!region)return;
+  const markup=liveFileBody();
+  if(region.dataset.markup===markup)return;
+  const expanded=region.querySelector('details')?.open;
+  const focused=region.querySelector('summary:focus');
+  region.dataset.markup=markup;region.innerHTML=markup;
+  const details=region.querySelector('details');
+  if(details&&expanded)details.open=true;
+  if(focused)details?.querySelector('summary')?.focus({preventScroll:true});
+}
+function updateLiveFilePulse(animate=false){
+  const label=$('project-file-pulse');
+  if(!label)return;
+  label.hidden=!liveStream.filePulse;
+  label.textContent=liveStream.filePulse?'Observed file change · '+liveStream.filePulse.path:'';
+  label.classList.remove('file-fresh');
+  if(animate&&!label.hidden)requestAnimationFrame(()=>{if(label.isConnected)label.classList.add('file-fresh');});
+}
+`;
+//# sourceMappingURL=brain-hub-live.js.map

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

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

package/dist/dashboard/brain-hub-managed-skills.d.ts

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

package/dist/dashboard/brain-hub-managed-skills.d.ts.map

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

package/dist/dashboard/brain-hub-managed-skills.js

@@ -0,0 +1,20 @@
+export const BRAIN_HUB_MANAGED_SKILLS = String.raw `
+function managedSkillControls(){
+  if(!local)return '';
+  const inventory=state.managedSkills;
+  const listBody=arr(inventory?.skills).length?list(arr(inventory.skills).map(item=>{
+    const choices=item.pendingAction?[item.pendingAction]:item.state==='enabled'?['disable','remove']:item.state==='disabled'?['enable','remove']:[];
+    const buttons=choices.map(kind=>action('managed-skill-preview','Preview '+kind,'quiet','data-kind="'+esc(kind)+'" data-id="'+esc(item.id)+'" '+(state.pending?'disabled':''))).join('');
+    return '<li class="item"><div class="row"><strong>'+esc(item.name)+'</strong>'+chip(item.state,item.state==='enabled'?'green':item.state==='disabled'?'':'amber')+'</div><small class="mono muted">'+esc(item.relativePath)+'</small><p class="small muted">'+esc(arr(item.targets).map(hostName).join(' · '))+'</p>'+(item.reason?'<p class="small amber">'+esc(item.reason)+'</p>':'')+(buttons?'<div class="actions">'+buttons+'</div>':'')+'</li>';
+  }).join('')):empty('No managed project skills','Skills applied through Project Kit appear here.',view('knowledge','Open Knowledge'));
+  const plan=state.managedSkillPlan;
+  const pending=plan?'<div class="panel-body stack"><div class="row"><h3>'+esc('Review '+plan.action)+'</h3>'+action('managed-skill-cancel','Cancel','quiet')+'</div>'+arr(plan.effects).map(effect=>'<p>'+esc(effect)+'</p>').join('')+
+    list(arr(plan.exactPaths).map(value=>'<li class="item mono small">'+esc(value)+'</li>').join(''))+
+    arr(plan.conflicts).map(value=>'<p class="small amber">'+esc(value)+'</p>').join('')+'<small class="muted">'+esc(plan.hostRefreshNote)+'</small>'+
+    (!arr(plan.conflicts).length?'<div class="actions">'+action('managed-skill-apply',plan.action==='remove'?'Remove verified skill':'Apply '+plan.action,plan.action==='remove'?'danger':'primary',state.pending?'disabled':'')+'</div>':'')+'</div>':'';
+  return panel('Managed project skills',(error('managedSkills','managed skills')||(!inventory?empty('Loading managed skills','Checking Project Kit receipts.'):listBody))+
+    (inventory?.invalidReceipts?'<p class="panel-body small amber">'+esc(inventory.invalidReceipts)+' ownership receipts could not be verified.</p>':'')+pending+
+    '<p class="panel-body small muted">Controls apply to skills generated by Project Kit in this workspace. Other skills and supporting files stay untouched.</p>');
+}
+`;
+//# sourceMappingURL=brain-hub-managed-skills.js.map

package/dist/dashboard/brain-hub-managed-skills.js.map

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

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

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

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

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

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

@@ -0,0 +1,44 @@
+export const BRAIN_HUB_NATIVE = String.raw `
+let nativeTimer=0,nativeBusy=false,nativeRequestEpoch=0,nativeReload=false;
+function invalidateNativeRequest(){nativeRequestEpoch++;clearTimeout(nativeTimer);}
+async function refreshNativeChats(manual=false){
+  if(document.hidden||state.view!=='sessions')return;
+  if(nativeBusy){nativeReload ||= manual;return;}
+  clearTimeout(nativeTimer);nativeBusy=true;
+  const epoch=state.dataEpoch,requestEpoch=nativeRequestEpoch;
+  const current=()=>epoch===state.dataEpoch&&requestEpoch===nativeRequestEpoch;
+  try{
+    const connection=await api('sessions/codex/status');
+    if(!current())return;
+    state.nativeConnection=connection;
+    if(connection.connected){
+      const query=new URLSearchParams({archived:String(!!state.nativeArchived),...(state.nativeListCursor?{cursor:state.nativeListCursor}:{})});
+      const result=await api('sessions/codex/threads?'+query,{timeoutMs:15000});
+      if(!current())return;
+      const selected=state.nativeThread?.thread;
+      state.nativeThreads=result;
+      const latest=arr(result.threads).find(item=>item.id===selected?.id);
+      if(selected&&latest&&(manual||latest.updatedAt!==selected.updatedAt)){
+        const page=await api('sessions/codex/threads/'+encodeURIComponent(selected.id)+(state.nativeThreadCursor?'?cursor='+encodeURIComponent(state.nativeThreadCursor):''),{timeoutMs:15000});
+        if(!current())return;
+        state.nativeThread=page;
+      }
+    }
+    delete state.errors.native;
+  }catch(failure){if(current())state.errors.native=failure.message;}
+  finally{
+    nativeBusy=false;
+    if(nativeReload){nativeReload=false;void refreshNativeChats(true);}
+    else if(current()&&state.view==='sessions'){render(true);if(state.nativeConnection?.connected)nativeTimer=setTimeout(()=>void refreshNativeChats(),10000);}
+  }
+}
+function nativeHistoryPanel(){
+  const connection=state.nativeConnection,threads=arr(state.nativeThreads?.threads),selected=state.nativeThread;
+  const actions=connection?.connected?action('native-refresh','Refresh original chats')+action('native-disconnect','Disconnect Codex'):action('native-connect','Connect installed Codex','primary');
+  const listMarkup=threads.length?list(threads.map(thread=>'<li><button class="entry" type="button" data-native-thread="'+esc(thread.id)+'"><strong>'+esc(thread.name??'Original title unavailable')+'</strong><small class="mono muted">'+esc(thread.id)+'</small><small>'+esc(isoTime(thread.updatedAt))+'</small></button></li>').join('')):empty(connection?.connected?'No conversations in this project':'Native history is disconnected',connection?.connected?'This list is scoped to the selected project directory. Check archived conversations if needed.':'Connect explicitly to read names and selected history through the installed Codex app-server.');
+  const preview=selected?'<div class="panel-body stack"><h3>'+esc(selected.thread.name??'Original title unavailable')+'</h3><dl class="facts">'+fact('Original conversation ID',selected.thread.id)+fact('Session group ID',selected.thread.sessionId??'Not supplied')+fact('Original workspace',selected.thread.cwd)+fact('History API runtime state',selected.thread.status?.type??'unknown')+fact('Observed',isoTime(selected.observedAt))+'</dl><p class="small muted">This separate app-server’s runtime state does not establish whether a desktop chat is working. Names are supplied by Codex; preview text is never substituted for a missing title.</p>'+list(arr(selected.messages).map(message=>'<li class="item"><strong>'+esc(message.role)+'</strong><p class="preserve">'+esc(message.text)+'</p><small class="mono muted">'+esc(message.locator)+'</small></li>').join(''))+'<p class="small muted">'+arr(selected.messages).length+' visible messages in this page. '+fmt(selected.omitted)+' non-text or unsupported items omitted. '+(selected.nextCursor?'Earlier history is available.':'No earlier page reported.')+'</p><div class="actions">'+action('native-import','Save this history page','primary')+(selected.nextCursor?action('native-earlier','Earlier history','','data-cursor="'+esc(selected.nextCursor)+'"'):'')+'</div><p class="small muted">Saving creates an immutable project snapshot of this page. It does not automatically approve the chat as project knowledge or resume a model.</p></div>':empty('Choose an original conversation','Inspect its exact title and visible history before saving a shared snapshot.');
+  const exports='<div class="panel-body"><form class="form" data-form="native-export"><label>Original tool<select name="tool"><option value="codex">Codex rollout / indexed export</option><option value="claude-code">Claude Code SDK / JSONL export</option><option value="opencode">OpenCode session export</option><option value="deepseek-harness">DeepSeek Harness canonical export</option></select></label><label>Native export file<input type="file" name="export" accept=".json,.jsonl,.ndjson,.zip" required></label><p class="small muted">Up to 2 MiB. DeepSeek ZIP imports read only the supported session record, never its attachments. Original names are kept when the export contains them; missing names stay unavailable.</p>'+submit('Import native history')+'</form></div>';
+  return panel('Original tool history','<div class="panel-body stack"><div class="actions">'+actions+chip(connection?.connected?'Read-only Codex API':'Explicit connection required',connection?.connected?'green':'amber')+'</div><p class="small muted">Connected lists refresh every 10 seconds while this view is open. History is read on selection or when the selected conversation’s timestamp changes. No model is started. The connection expires after 15 minutes.</p>'+error('native','native history')+(connection?.connected?'<div class="actions">'+action('native-archive',state.nativeArchived?'Show current chats':'Show archived chats')+(state.nativeThreads?.nextCursor?action('native-next','Next conversations','','data-cursor="'+esc(state.nativeThreads.nextCursor)+'"'):'')+(state.nativeListCursor?action('native-first','First conversations'):'')+'</div>':'')+'</div><div class="two"><div>'+listMarkup+'</div>'+preview+'</div><details><summary class="panel-body">Import an export from another supported tool</summary>'+exports+'</details>');
+}
+`;
+//# sourceMappingURL=brain-hub-native.js.map

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

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

package/dist/dashboard/brain-hub-project-views.d.ts

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

package/dist/dashboard/brain-hub-project-views.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brain-hub-project-views.d.ts","sourceRoot":"","sources":["../../src/dashboard/brain-hub-project-views.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,uBAAuB,QA6EnC,CAAC"}

package/dist/dashboard/brain-hub-project-views.js

@@ -0,0 +1,80 @@
+import { BRAIN_HUB_KNOWLEDGE } from './brain-hub-knowledge.js';
+export const BRAIN_HUB_PROJECT_VIEWS = String.raw `
+${BRAIN_HUB_KNOWLEDGE}
+function projectRequired(title,description){
+  return heading(title,description)+panel('Project workspace required','<div class="panel-body stack"><p class="muted">Open a project-local workspace from its directory to access its documents, work room and learning history.</p><pre>shadow-brain project workspace .</pre>'+action('copy-project-command','Copy launch command')+'</div>');
+}
+function projectHubError(title){
+  return panel(title,error('hub','project hub')||empty('Reading project hub','The project-local store is loading.'));
+}
+function skillPanel(){
+  const input=state.skillInput??{};
+  const form='<form class="form" data-form="skill"><label>Project requirement<textarea name="requirement" rows="3" maxlength="3000" required>'+esc(input.requirement)+'</textarea></label><div class="form-grid"><label>Host target<select name="target">'+['codex','claude-code','opencode','deepseek-harness','portable'].map(target=>'<option value="'+target+'" '+(target===input.target?'selected':'')+'>'+esc(hostName(target))+'</option>').join('')+'</select></label><label>Skill name<input name="name" maxlength="64" value="'+esc(input.name)+'" placeholder="optional-skill-name"></label></div><label>Approved project knowledge<textarea name="knowledge" rows="2" maxlength="4000">'+esc(input.knowledge)+'</textarea></label>'+submit('Preview project skill')+'</form>';
+  const plan=state.skill;
+  const files=arr(plan?.files);
+  const result=plan?'<div class="receipt"><div class="row"><strong>'+esc(plan.name??'Applied skill')+'</strong>'+chip(plan.applied?'Applied':'Preview ready',plan.applied?'green':'cyan')+'</div>'+files.map(file=>'<details><summary>'+esc(file.relativePath)+' · '+esc(file.status)+'</summary>'+(file.content?'<pre>'+esc(file.content)+'</pre>':'')+(file.reason?'<p class="small amber">'+esc(file.reason)+'</p>':'')+'</details>').join('')+arr(plan.warnings).map(warning=>'<p class="small amber">'+esc(warning)+'</p>').join('')+(!plan.applied&&!files.some(file=>file.status==='conflict')?action('apply-skill','Apply reviewed plan','primary'):'')+'</div>':'';
+  return panel('Project skill','<div class="panel-body stack">'+form+result+'</div>');
+}
+function docPageMarkup(){
+  const record=state.documents;
+  if(!record)return empty('Select a document','Choose an uploaded PDF to see its extracted page text and citation.');
+  const doc=record.document,pages=arr(record.pages);
+  const page=pages.find(item=>item.page===state.docPage);
+  const prev=pages.findLast(item=>item.page<state.docPage),next=pages.find(item=>item.page>state.docPage);
+  return '<div class="panel-body stack"><div class="row"><div><h3>'+esc(doc.name)+'</h3><p class="small muted">'+fmt(doc.pageCount)+' pages · '+esc(doc.parser??'Parser unavailable')+'</p></div>'+chip(doc.status,doc.status==='ready'?'green':'amber')+'</div>'+
+    (doc.error?'<p class="small amber">'+esc(doc.error)+'</p>':'')+'<details><summary>Document fingerprint</summary><pre>'+esc(doc.sha256)+'</pre></details>'+
+    (page?'<div class="actions">'+btn('Previous page','data-page="'+(prev?.page??'')+'" '+(prev?'':'disabled'))+btn('Next page','data-page="'+(next?.page??'')+'" '+(next?'':'disabled'))+chip('Page '+page.page)+chip(page.status,page.status==='approved'?'green':'amber')+'</div>'+(page.truncated?'<p class="small amber">Extraction reached the text limit. Approval stores only the excerpt shown here.</p>':'')+'<pre>'+esc(page.text||'This page has no extracted text. OCR is unavailable in this workspace.')+'</pre>'+(page.citation?'<p class="small mono cyan">'+esc(typeof page.citation==='string'?page.citation:JSON.stringify(page.citation))+'</p>':'')+
+      (page.status==='pending'&&page.text?'<div class="actions">'+action('review-page','Approve page','primary','data-decision="approve"')+action('review-page','Reject page','','data-decision="reject"')+'</div>':'')+(page.memoryId?action('open-memory','Inspect approved memory','','data-memory="'+esc(page.memoryId)+'"'):''):'')+'</div>';
+}
+function knowledgePage(){
+  if(!local)return projectRequired('Knowledge intake','Review sources and commit project-local knowledge.');
+  const docs=arr(state.hub?.documents);
+  const queue=docs.length?list(docs.map(doc=>'<li><button class="entry" type="button" data-document="'+esc(doc.id)+'" aria-pressed="'+(doc.id===state.documents?.document?.id)+'"><strong>'+esc(doc.name)+'</strong><small class="muted">'+esc(doc.status)+' · '+fmt(doc.pageCount)+' pages</small></button></li>').join(''),'class="list section-list"'):empty('No PDFs uploaded','Choose a local PDF to extract and review its pages.');
+  const pdfEnabled=state.server?.capabilities?.pdf!==false;
+  const pdf=state.hub?queue+(pdfEnabled?'<div class="panel-body"><form class="form" data-form="upload"><label>PDF source<input name="pdf" type="file" accept="application/pdf,.pdf" required></label><p class="small muted">'+(state.hub.limits?.pdfBytes?fmt(state.hub.limits.pdfBytes/1024)+' KiB maximum. ':'')+'Review extracted text before adding it to memory.</p>'+submit('Upload PDF')+'</form></div>':''):error('hub','document queue')||empty('Loading document queue','Reading project-local document records.');
+  const profile=state.profile;
+  const project=profile?'<div class="panel-body stack"><dl class="facts">'+fact('Stack',arr(profile.stack).join(' · ')||'No markers found')+fact('Package managers',arr(profile.packageManagers).join(' · ')||'No markers found')+'</dl>'+arr(profile.warnings).map(text=>'<p class="small amber">'+esc(text)+'</p>').join('')+(arr(profile.evidence).length?'<details><summary>Observed project evidence</summary>'+list(profile.evidence.map(item=>'<li class="item mono small">'+esc(item.path)+' · '+esc(arr(item.signals).join(', '))+'</li>').join(''))+'</details>':'')+'</div>':error('profile','project profile')||empty('Reading project profile','Inspecting bounded project-local markers.');
+  return heading('Knowledge for this project','Save ordinary notes and facts for your connected agents to recall.',view('context','Try a question'))+evidencePanel()+'<div class="two">'+teachPanel()+panel('Saved notes and review',sourceReview())+'</div><div class="two" style="margin-top:10px">'+panel('Saved sources',sourceLibrary())+panel('Observed project profile',project)+'</div><details class="panel-body" '+(state.documents?'open':'')+'><summary>Optional: PDF library and page review</summary><div class="two" style="margin-top:10px">'+panel('PDF library',pdf)+panel('Page review',docPageMarkup())+'</div></details>'+skillPanel();
+}
+function roomAction(kind,label,id,extra=''){return btn(label,'data-room-action="'+kind+'" data-id="'+esc(id)+'" '+extra);}
+function operator(actor){return actor?.kind==='user'&&actor.id==='Operator';}
+function roomPage(){
+  if(!local)return projectRequired('Shared work room','Exchange proposals, tasks, artifacts and outcomes in a project-local room.');
+  if(!state.hub)return heading('Shared work room','Coordinate proposals, artifacts and outcomes.')+projectHubError('Rooms');
+  const rooms=arr(state.hub.rooms),current=state.room;
+  const roster=(rooms.length?list(rooms.map(room=>'<li><button class="entry" type="button" data-room="'+esc(room.id)+'" aria-pressed="'+(room.id===current?.room?.id)+'"><strong>'+esc(room.goal)+'</strong><small class="muted">'+esc(isoTime(room.createdAt))+'</small></button></li>').join(''),'class="list section-list"'):empty('No work rooms','Create a room for a shared project goal.'))+
+    '<div class="panel-body"><form class="form" data-form="room"><label>Room goal<textarea name="goal" rows="2" maxlength="400" required></textarea></label>'+submit('Create room')+'</form></div>';
+  if(!current)return heading('Shared work room','Coordinate proposals, artifacts and outcomes.')+'<div class="two">'+panel('Project rooms',roster)+panel('Discussion',empty('No room selected','Choose a project room or create a room for this task.'))+'</div>';
+  const messages=arr(current.messages);
+  const messageForm='<div class="panel-body"><form class="form" data-form="message"><div class="form-grid"><label>Message type<select name="type">'+['proposal','critique','question','answer','decision','handoff','status'].map(type=>'<option>'+type+'</option>').join('')+'</select></label><label>Reply to<select name="replyTo"><option value="">No reply</option>'+messages.map(message=>'<option value="'+esc(message.id)+'">'+esc(message.type+' · '+message.text.slice(0,60))+'</option>').join('')+'</select></label></div><label>Message<textarea name="text" rows="2" maxlength="3000" required></textarea></label>'+submit('Post message')+'</form></div>';
+  const discussion='<div class="panel-body"><h3>'+esc(current.room.goal)+'</h3><p class="small muted mono">'+esc(current.room.id)+'</p></div>'+list(messages.map(message=>'<li class="item"><div class="row"><span>'+chip(message.type,'cyan')+' <strong>'+esc(hostName(message.author?.id))+'</strong></span><time class="small muted mono">'+esc(time(message.createdAt))+'</time></div><p>'+esc(message.text)+'</p>'+(message.replyTo?'<small class="muted">Reply to '+esc(message.replyTo)+'</small>':'')+(!operator(message.author)?'<div class="actions">'+roomAction('ack-message','Acknowledge message',message.id)+'</div>':'')+'</li>').join(''),'class="list section-list"')+messageForm;
+  const tasks=arr(current.tasks), artifacts=arr(current.artifacts),outcomes=arr(current.outcomes);
+  const taskList=list(tasks.map(task=>'<li class="item"><div class="row"><strong>'+esc(task.title)+'</strong>'+chip(task.status,task.status==='completed'?'green':'')+'</div><small class="muted">'+esc(task.owner?'Owner '+hostName(task.owner.id)+(task.leaseUntil?' · lease '+isoTime(task.leaseUntil):''):'Unclaimed')+'</small><div class="actions">'+(task.status==='open'?roomAction('claim','Claim',task.id,'data-revision="'+esc(task.revision)+'"'):task.status==='claimed'&&operator(task.owner)?roomAction('renew','Renew',task.id,'data-revision="'+esc(task.revision)+'"')+roomAction('release','Release',task.id,'data-revision="'+esc(task.revision)+'"'):'')+'</div></li>').join(''));
+  const taskForm='<div class="panel-body"><form class="form" data-form="task"><label>Task title<input name="title" maxlength="240" required></label>'+submit('Add task')+'</form></div>';
+  const artifactsMarkup=artifacts.length?list(artifacts.map(item=>'<li class="item"><div class="row"><strong>'+esc(item.path)+'</strong>'+chip(item.status)+'</div><small class="muted mono">'+esc(item.sha256)+'</small><div class="actions"><a class="btn" href="/api/workspace/hub/rooms/'+encodeURIComponent(current.room.id)+'/artifacts/'+encodeURIComponent(item.id)+'">Download</a>'+(item.status==='submitted'&&tasks.some(task=>task.id===item.taskId&&task.artifactId===item.id&&task.status==='claimed')?roomAction('accept','Accept artifact',item.id):'')+(!operator(item.author)?roomAction('ack-artifact','Acknowledge',item.id,'data-sha256="'+esc(item.sha256)+'"'):'')+'</div></li>').join('')):'';
+  const taskOptions=tasks.map(item=>'<option value="'+esc(item.id)+'">'+esc(item.title)+'</option>').join('');
+  const claimed=tasks.filter(item=>item.status==='claimed'&&operator(item.owner));
+  const artifactForm=claimed.length?'<div class="panel-body"><form class="form" data-form="artifact"><label>Claimed task<select name="taskId">'+claimed.map(item=>'<option value="'+esc(item.id)+'">'+esc(item.title)+'</option>').join('')+'</select></label><label>Project-relative artifact path<input name="path" maxlength="400" required></label>'+submit('Attach artifact')+'</form></div>':'';
+  const outcomeForm=tasks.length?'<div class="panel-body"><form class="form" data-form="outcome"><label>Task<select name="taskId">'+taskOptions+'</select></label><label>Artifact<select name="artifactId"><option value="">No artifact</option>'+artifacts.map(item=>'<option value="'+esc(item.id)+'">'+esc(item.path)+'</option>').join('')+'</select></label><label>Result<select name="result"><option>pass</option><option>fail</option><option>partial</option></select></label><label>Acceptance check<input name="check" maxlength="240" required></label><label>Evidence<textarea name="evidence" maxlength="3000" rows="2" required></textarea></label>'+submit('Record outcome')+'</form></div>':'';
+  const outcomeRows=list(outcomes.map(item=>'<li class="item"><div class="row"><strong>'+esc(item.check)+'</strong>'+chip(item.result,item.result==='pass'?'green':'amber')+'</div><p class="small muted">'+esc(item.evidence)+'</p><small class="muted">'+esc(item.provenance)+'</small>'+btn('Propose lesson','data-lesson-from="'+esc(item.id)+'"','quiet')+'</li>').join(''));
+  const acks=arr(current.acknowledgements);
+  const right='<div class="panel-head"><h2>Tasks</h2>'+chip(tasks.length)+'</div>'+taskList+taskForm+'<div class="panel-head"><h2>Artifacts and outcomes</h2>'+chip(artifacts.length+outcomes.length)+'</div>'+artifactsMarkup+artifactForm+outcomeRows+outcomeForm+
+    (acks.length?'<details class="panel-body"><summary>'+acks.length+' acknowledgements</summary>'+list(acks.map(item=>'<li class="item small">'+esc(hostName(item.author?.id))+' · '+esc(item.targetType)+' · <span class="mono">'+esc(item.targetId)+'</span></li>').join(''))+'</details>':'');
+  return heading('Shared work room','Coordinate proposals, artifacts and outcomes.',action('refresh-room','Refresh room'))+'<div class="three">'+panel('Project rooms',roster)+panel('Discussion',discussion,chip(messages.length))+'<section class="panel">'+right+'</section></div>';
+}
+function lessonAction(kind,label,id){return btn(label,'data-lesson-action="'+kind+'" data-id="'+esc(id)+'"');}
+function learningPage(){
+  if(!local)return projectRequired('Memory and learning','Evaluate source-backed lessons and review their recorded outcomes.');
+  if(!state.hub)return heading('Memory and learning','Evaluate project lessons against observed outcomes.')+projectHubError('Lessons');
+  const lessons=arr(state.hub.lessons);
+  const outcomes=arr(state.room?.outcomes);
+  const lessonForm=outcomes.length?'<div class="panel-body"><form class="form" data-form="lesson"><label>Recorded outcome<select name="outcomeId">'+outcomes.map(item=>'<option value="'+esc(item.id)+'" '+(state.lessonFrom===item.id?'selected':'')+'>'+esc(item.check)+'</option>').join('')+'</select></label><label>Lesson title<input name="title" maxlength="150" required></label><label>Lesson and scope<textarea name="text" rows="3" maxlength="4000" required></textarea></label>'+submit('Record lesson candidate')+'</form></div>':empty('No room outcome selected','Open a work room with a recorded outcome to propose a lesson.',view('room','Open collaboration'));
+  const rows=lessons.length?list(lessons.map(lesson=>'<li class="item"><div class="row"><h3>'+esc(lesson.title)+'</h3>'+chip(lesson.status,lesson.status==='promoted'?'green':'amber')+'</div><p>'+esc(lesson.text)+'</p><small class="muted mono">Outcome '+esc(lesson.outcomeId)+'</small>'+
+    (lesson.evaluation?'<dl class="facts">'+fact('Baseline',lesson.evaluation.baseline?'Pass':'Fail')+fact('Candidate',lesson.evaluation.candidate?'Pass':'Fail')+fact('Control',lesson.evaluation.control?'Pass':'Fail')+fact('Evidence',lesson.evaluation.evidence)+fact('Provenance',lesson.evaluation.provenance)+'</dl>':'')+
+    (['candidate','evaluated'].includes(lesson.status)&&!lesson.memoryId?'<details><summary>'+esc(lesson.evaluation?'Update operator-reported comparison':'Record operator-reported comparison')+'</summary><form class="form" data-form="evaluate" data-id="'+esc(lesson.id)+'"><p class="small muted">Report the results of checks you ran outside this workspace.</p><label class="check"><input type="checkbox" name="baseline" '+(lesson.evaluation?.baseline?'checked':'')+'> Baseline passed</label><label class="check"><input type="checkbox" name="candidate" '+(lesson.evaluation?.candidate?'checked':'')+'> Candidate passed</label><label class="check"><input type="checkbox" name="control" '+(lesson.evaluation?.control?'checked':'')+'> Safety controls passed</label><label>Evaluation evidence<textarea name="evidence" maxlength="4000" rows="2" required>'+esc(lesson.evaluation?.evidence)+'</textarea></label>'+submit('Record evaluation')+'</form></details>':'')+
+    '<div class="actions">'+(lesson.status==='evaluated'&&lesson.evaluation&&!lesson.evaluation.baseline&&lesson.evaluation.candidate&&lesson.evaluation.control?lessonAction('promote','Promote lesson',lesson.id):lesson.status==='promoted'?lessonAction('rollback','Roll back lesson',lesson.id):'')+(lesson.memoryId?action('open-memory','Inspect lesson memory','','data-memory="'+esc(lesson.memoryId)+'"'):'')+'</div></li>').join('')):empty('No candidate lessons','Record a work-room outcome to create a candidate for review.');
+  const feedback=state.feedback;
+  return heading('Memory and learning','Save useful knowledge, test it on a task, and correct what does not help.')+panel('How learning works','<div class="panel-body"><ol><li>Add and approve knowledge in this project.</li><li>Use a context pack in your agent and check the result.</li><li>Mark memories useful, irrelevant, or incorrect.</li><li>For repeatable improvements, record a work-room outcome, compare a lesson, and promote or roll it back.</li></ol><p class="small muted">The system adapts stored memory and retrieval. It does not train the connected model or verify an outcome you report.</p></div>')+panel('Learn from your feedback',feedbackControls())+'<div class="two">'+panel('Propose a lesson',lessonForm)+panel('Lesson history',rows,chip(lessons.length))+'</div>';
+}
+`;
+//# sourceMappingURL=brain-hub-project-views.js.map

package/dist/dashboard/brain-hub-project-views.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brain-hub-project-views.js","sourceRoot":"","sources":["../../src/dashboard/brain-hub-project-views.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,MAAM,CAAC,MAAM,uBAAuB,GAAG,MAAM,CAAC,GAAG,CAAA;EAC/C,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4EpB,CAAC"}

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

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

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

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

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

@@ -0,0 +1,40 @@
+import { BRAIN_HUB_NATIVE } from './brain-hub-native.js';
+export const BRAIN_HUB_SESSIONS = String.raw `
+${BRAIN_HUB_NATIVE}
+async function refreshSessions(){
+  state.sessions=await api('sessions');
+  if(state.session)state.session=await api('sessions/'+state.session.session.id+(state.sessionBefore?'?before='+encodeURIComponent(state.sessionBefore):''));
+}
+function sessionPresence(session){return session.presence==='completed'?'Completed':session.presence==='stale'?'Stale report':session.reportedStatus==='waiting'?'Recently reported waiting':'Recently reported working';}
+function sessionHandoff(checkpoint){
+  return '<div class="stack"><p class="preserve">'+esc(checkpoint.summary)+'</p>'+[['decisions','Decisions'],['completed','Completed work'],['nextSteps','Next steps'],['evidence','Evidence references']].map(([key,label])=>arr(checkpoint[key]).length?'<h3>'+label+'</h3>'+list(checkpoint[key].map(item=>'<li class="item">'+esc(item)+'</li>').join('')):'').join('')+'<details><summary>Immutable checkpoint fingerprint</summary><pre>'+esc(checkpoint.sha256)+'</pre></details></div>';
+}
+function sessionRoster(sessions){
+  const groups=new Map();for(const session of sessions){const tool=session.native?.tool??session.actor.tool;groups.set(tool,[...groups.get(tool)??[],session]);}
+  return '<div class="table-wrap"><table><thead><tr><th>Reporting tool</th><th>Recently working</th><th>Waiting / stale</th><th>Completed</th><th>Worker sessions</th></tr></thead><tbody>'+[...groups].map(([tool,rows])=>'<tr><td>'+esc(hostName(tool))+'</td><td>'+rows.filter(s=>s.presence==='recent'&&s.reportedStatus==='working').length+'</td><td>'+rows.filter(s=>s.presence!=='completed'&&(s.reportedStatus==='waiting'||s.presence==='stale')).length+'</td><td>'+rows.filter(s=>s.presence==='completed').length+'</td><td>'+rows.filter(s=>s.parentSessionId&&!s.resumedFrom).length+'</td></tr>').join('')+'</tbody></table></div><p class="panel-body small muted">Counts describe registered sessions in this workspace. Recent means a report arrived within '+Math.round((state.sessions?.limits?.recentMs??300000)/60000)+' minutes, not continuous proof of execution. A resumed session is separate from a worker session.</p>';
+}
+function sessionsPage(){
+  if(!local)return projectRequired('Sessions and handoffs','Keep project conversations and resumable checkpoints together.');
+  const sessions=arr(state.sessions?.sessions),detail=state.session,current=detail?.session;
+  const queue=error('sessions','sessions')||(sessions.length?list(sessions.slice().reverse().map(session=>'<li><button class="entry" type="button" data-session="'+esc(session.id)+'" aria-pressed="'+(session.id===current?.id)+'"><strong>'+esc(session.title)+'</strong><small>'+esc(hostName(session.native?.tool??session.actor.tool))+' · '+esc(sessionPresence(session))+'</small><small class="muted">Last report '+esc(isoTime(session.lastReportedAt))+'</small></button></li>').join('')):empty('No registered conversations','Connected hosts can register a session and save a checkpoint. You can also begin a manual project conversation below.'));
+  const create='<div class="panel-body"><form class="form" data-form="session-open"><label>Conversation title<input name="title" maxlength="160" required></label><label>What are you trying to achieve?<textarea name="goal" rows="2" maxlength="1200" required></textarea></label>'+submit('Start portal session')+'</form><p class="small muted">This creates a portal-owned record. It does not launch an AI model.</p></div>';
+  let body=empty('Choose a conversation','Open a recent or completed session to inspect messages and handoffs.');
+  if(current){
+    const reportingTool=current.native?.tool??current.actor.tool;
+    const matched=arr(state.usage?.receipts).filter(receipt=>receipt.projectId===state.project&&current.hostSessionId&&receipt.sessionId===current.hostSessionId&&receipt.agent===reportingTool);
+    const controls=arr(state.policy?.chats).find(chat=>chat.id===current.id);
+    const latestModel=matched.at(-1);
+    const messages='<p class="small muted">Showing '+arr(detail.messages).length+' of '+fmt(detail.messageCount??arr(detail.messages).length)+' retained messages.</p><div class="actions">'+(detail.nextBefore?action('session-older','Earlier messages','','data-before="'+esc(detail.nextBefore)+'"'):'')+(state.sessionBefore?action('session-latest','Latest messages'):'')+'</div>'+list(arr(detail.messages).map(message=>'<li class="item"><div class="row"><strong>'+esc(message.source?'Imported '+message.source.originalRole:message.role)+'</strong><small class="muted">'+esc(isoTime(message.createdAt))+'</small></div><p class="preserve">'+esc(message.text)+'</p><small class="mono muted">'+esc(message.source?message.source.sourceId+' · '+message.source.locator:hostName(message.actor.tool))+'</small></li>').join(''));
+    const note=current.reportedStatus!=='completed'?'<form class="form" data-form="session-note"><label>Message or work note<textarea name="text" maxlength="8000" rows="3" required></textarea></label>'+submit('Record note')+'</form>':'';
+    const checkpoint='<details><summary>Save a handoff for another agent</summary><form class="form" data-form="session-checkpoint"><label>Summary of the work<textarea name="summary" maxlength="4000" rows="3" required></textarea></label>'+[['decisions','Decisions'],['completed','Completed work'],['nextSteps','Next steps'],['evidence','Evidence references']].map(([name,label])=>'<label>'+label+' · one per line<textarea name="'+name+'" rows="2" maxlength="4800"></textarea></label>').join('')+submit('Save immutable checkpoint')+'</form></details>';
+    const permits=!!controls&&controls.shareContext&&!controls.inheritedBlocked&&!state.errors.policy;
+    const checkpoints=list(arr(detail.checkpoints).slice().reverse().map(cp=>'<li class="item"><div class="row"><strong>Checkpoint · revision '+esc(cp.revision)+'</strong><small>'+esc(isoTime(cp.createdAt))+'</small></div>'+(state.sessionCheckpoint?.id===cp.id?sessionHandoff(state.sessionCheckpoint):action('session-checkpoint-open','Read checkpoint','','data-checkpoint="'+esc(cp.id)+'"'))+'<div class="actions">'+(permits?action('copy-resume','Copy agent resume request','','data-checkpoint="'+esc(cp.id)+'"'):'')+action('session-resume','Continue in portal','','data-checkpoint="'+esc(cp.id)+'"')+'</div></li>').join(''));
+    const sharing=controls?'<div class="row"><p class="small muted">'+(permits?'Available to agents':'Agent delivery off')+' · Role '+esc(controls.role??'Unassigned')+'</p>'+
+      action('session-policy','Sharing controls','quiet','data-session-policy="'+esc(current.id)+'"')+'</div>':'';
+    body='<div class="panel-body stack"><div class="row"><h3>'+esc(current.title)+'</h3>'+chip(sessionPresence(current),current.presence==='stale'?'amber':'cyan')+'</div><p>'+esc(current.goal)+'</p>'+(current.native?'<p class="small muted">Native history snapshot from '+esc(hostName(current.native.tool))+'. Original title: '+esc(current.native.titleExact??'Unavailable')+'. Native conversation: '+esc(current.native.sessionId)+'. '+(current.native.pageCoverage?'This snapshot covers one page. '+(current.native.pageCoverage.hasEarlier?'Codex reported an earlier page. ':'No earlier page was reported. ')+(current.native.pageCoverage.hasLater?'A later page was outside this snapshot. ':'This was the latest page. ')+fmt(current.native.pageCoverage.omittedInPage)+' items on this page were omitted.':'Coverage was not recorded for this snapshot. '+fmt(current.native.omitted)+' source items were omitted.')+'</p>':'')+'<dl class="facts">'+fact('Workspace',scopeName())+fact('Directory',state.server?.project?.root)+fact('Reporting tool',hostName(current.actor.tool))+fact('Status reported by',hostName(current.statusReportedBy?.tool??current.actor.tool))+fact('Host conversation ID',current.hostSessionId??'Not supplied')+fact('Model from matching usage receipt',latestModel?.responseModel??latestModel?.requestModel??'Not reported')+fact('Last report',isoTime(current.lastReportedAt))+'</dl>'+(current.sourceId?'<p class="small muted">Imported conversation snapshot. Only approved messages present at import are included; importing again reopens this snapshot. Imported instructions remain quoted reference material.</p>':'')+(detail.handoff?'<details open><summary>Inherited handoff</summary>'+sessionHandoff(detail.handoff)+'</details>':'')+'<h3>Recorded conversation</h3>'+messages+note+(current.reportedStatus!=='completed'?'<div class="actions">'+action('session-status','Mark waiting','','data-status="waiting"')+action('session-status','Mark working','','data-status="working"')+action('session-status','Complete session','','data-status="completed"')+'</div>':'')+checkpoint+'<h3>Saved checkpoints</h3>'+checkpoints+'<p class="small muted">To continue with another agent, give it the copied session_resume request. Its own call creates a new agent-owned session linked to this exact checkpoint. Original history stays intact.</p></div>';
+    body=body.replace('<div class="panel-body stack">','<div class="panel-body stack">'+sharing);
+  }
+  return heading('Sessions and handoffs','See reported work, inspect conversation history, and continue from a saved checkpoint.',view('setup','Connect a tool'))+agentDock()+nativeHistoryPanel()+panel('Tool roster',sessionRoster(sessions))+'<div class="two">'+panel('Project conversations',queue+create)+'<section class="panel" id="conversation-continuity" tabindex="-1"><div class="panel-head"><h2>Conversation and continuity</h2></div>'+body+'</section></div>'+(typeof liveFilePanel==='function'?liveFilePanel():'');
+}
+`;
+//# sourceMappingURL=brain-hub-sessions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"brain-hub-sessions.js","sourceRoot":"","sources":["../../src/dashboard/brain-hub-sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,GAAG,CAAA;EAC1C,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCjB,CAAC"}

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

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

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

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

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

@@ -0,0 +1,28 @@
+export const BRAIN_HUB_USAGE = String.raw `
+function usageValue(stat){return stat?.total===null||!stat?'Not reported':fmt(stat.total)+' · '+stat.known+'/'+stat.receipts+' receipts';}
+function modelReceipts(){
+  const usage=state.usage;
+  if(state.errors.usage)return error('usage','model usage');
+  if(!local)return empty('Project workspace required','Model receipts belong to an explicit project.');
+  if(!usage)return empty('Loading usage receipts','Reading project-local host reports.');
+  if(!arr(usage.receipts).length)return empty('No model usage reported yet','A connected host can call usage_report with the model and token counts it already knows. Installing a recipe alone does not supply this data.');
+  return '<div class="table-wrap"><table><thead><tr><th>Reporting host</th><th>Provider / requested model</th><th>Response model</th><th>Input</th><th>Output</th><th>Last report</th></tr></thead><tbody>'+arr(usage.models).map(row=>'<tr><td>'+esc(hostName(row.agent))+'</td><td>'+esc(row.provider??'Unknown provider')+'<br>'+esc(row.requestModel??'Not reported')+'</td><td>'+esc(row.responseModel??'Not reported')+'</td><td>'+esc(usageValue(row.totals.inputTokens))+'</td><td>'+esc(usageValue(row.totals.outputTokens))+'</td><td>'+esc(isoTime(row.lastAt))+'</td></tr>').join('')+'</tbody></table></div><p class="panel-body small muted">Host-reported metadata. A reported model name is not independent proof of which upstream model a proxy used.</p>';
+}
+function modelsPage(){
+  const hosts=arr(state.integrations?.agents);
+  const body=hosts.length?'<div class="table-wrap"><table><thead><tr><th>Client recipe</th><th>Project skill files</th><th>Retained exchanges</th><th>Usage reports</th></tr></thead><tbody>'+hosts.map(host=>{
+    const events=state.events.filter(event=>event.agent===host.id),latest=events.at(-1),reports=arr(state.usage?.receipts).filter(receipt=>receipt.agent===host.id);
+    return '<tr><td><strong>'+esc(host.label)+'</strong></td><td>'+esc(host.installation)+'</td><td>'+esc(latest?evidence(latest)+' · '+eventLabel(latest)+' · '+isoTime(latest.timestamp):state.live?'Not observed for this label':'Activity display is off')+'</td><td>'+esc(reports.length?reports.length+' retained':'Not reported')+'</td></tr>';
+  }).join('')+'</tbody></table></div><p class="panel-body small muted">Recipe, skill files, observed calls and usage receipts are separate checks. Host labels must match for these rows; all reporting labels appear below. These records do not assert a persistent live connection.</p>':error('integrations','client checks')||empty('Reading integration evidence','Client skill-file checks are loading.');
+  return heading('Connections and models','See what is installed, what exchanged data, and what each host reported.',view('setup','Configure hosts'))+panel('Client readiness',body)+panel('Reported models',modelReceipts(),chip('Host-reported','amber'));
+}
+function usagePage(){
+  const measured=state.events.filter(event=>event.source==='measured'&&event.kind==='tool-end');
+  const durations=measured.map(event=>event.durationMs).filter(Number.isFinite);
+  const usage=state.usage,totals=usage?.totals;
+  const usageBody=totals?(state.errors.usage?'<div class="panel-body"><p class="amber" role="status">Usage refresh failed. Showing the last readable snapshot.</p><p class="small muted">'+esc(state.errors.usage)+'</p></div>':'')+'<div class="panel-body stack"><dl class="facts">'+fact('Input tokens',usageValue(totals.inputTokens))+fact('Output tokens',usageValue(totals.outputTokens))+fact('Cache read · part of input',usageValue(totals.cacheReadInputTokens))+fact('Cache write · part of input',usageValue(totals.cacheWriteInputTokens))+fact('Reasoning · part of output',usageValue(totals.reasoningOutputTokens))+'</dl><p class="small muted">Cache and reasoning counts are subsets. They are never added again to input and output. Unknown counts stay unknown; coverage shows how many receipts supplied each figure.</p><dl class="facts">'+fact('Retained receipts',arr(usage.receipts).length+' / '+usage.retentionLimit)+fact('Older receipts removed',usage.dropped)+fact('Coverage starts',isoTime(usage.oldestAt))+fact('Latest receipt',isoTime(usage.newestAt))+fact('Recording',usage.recording?'On':'Off')+'</dl><p class="small muted">These are totals for retained receipts, not lifetime billing. Dollar cost and provider savings are not calculated.</p></div>':error('usage','usage receipts')||empty('No usage evidence','Usage arrives when a host explicitly sends a report.');
+  const context=state.context;
+  return heading('Usage and timing','Reported model tokens, measured tool timing, and estimated context size are kept separate.')+'<div class="two">'+panel('Reported model tokens',usageBody,chip('Host-reported','amber'))+panel('Tool timing and context','<div class="panel-body stack"><dl class="facts">'+fact('Measured tool returns',state.live?fmt(measured.length):undefined)+fact('Measured tool duration',durations.length?fmt(durations.reduce((sum,item)=>sum+item,0))+' ms':undefined)+fact('Timing coverage',durations.length+' / '+measured.length)+fact('Last context estimate',context?fmt(context.budget.estimatedTokens)+' tokens':'Build a context pack')+fact('Exact context characters',context?fmt(context.budget.usedChars):undefined)+'</dl><p class="small muted">Tool time is not model inference time. Context estimates describe the returned pack; they do not prove billed token savings.</p>'+view('context','Inspect context selection')+'</div>')+'</div>'+panel('Model breakdown',modelReceipts());
+}
+`;
+//# sourceMappingURL=brain-hub-usage.js.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"brain-hub-views.d.ts","sourceRoot":"","sources":["../../src/dashboard/brain-hub-views.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,eAAe,QAiJmB,CAAC"}