@theihtisham/agent-shadow-brain 7.1.4 → 7.22.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,82 @@
+export const BRAIN_HUB_EXCHANGES = String.raw `
+function exchangeKey(event){
+  if(event?.source!=='measured'||event.transport!=='mcp'||!['tool-start','tool-end'].includes(event.kind)||
+    !event.projectId||!event.sessionId||!event.agent||!event.tool||!event.correlationId)return null;
+  return JSON.stringify([event.projectId,event.sessionId,event.agent,event.tool,event.correlationId]);
+}
+function exchangeClientKey(event){return JSON.stringify([event.projectId,event.agent,event.sessionId]);}
+let exchangeCache={events:null,pairs:new Map(),clients:[]};
+function observedExchanges(){
+  if(exchangeCache.events===state.events)return exchangeCache;
+  const exchanges=new Map(),clients=new Map(),pairs=new Map();
+  for(const event of state.events){
+    const key=exchangeKey(event);
+    if(!key)continue;
+    const pair=exchanges.get(key)??{requests:[],results:[]};
+    if(event.kind==='tool-start')pair.requests.push(event);
+    else pair.results.push(event);
+    exchanges.set(key,pair);
+    const client=exchangeClientKey(event);
+    clients.delete(client);
+    clients.set(client,event);
+  }
+  for(const pair of exchanges.values()){
+    const request=pair.requests[0],result=pair.results[0];
+    if(pair.requests.length!==1||pair.results.length!==1||request.sequence>=result.sequence)continue;
+    pairs.set(request.id,result);
+    pairs.set(result.id,request);
+  }
+  exchangeCache={events:state.events,pairs,clients:[...clients.values()].reverse()};
+  return exchangeCache;
+}
+function exchangeLabel(event){
+  return event.kind==='tool-start'?'Request observed':event.outcome==='success'?'Result ready':
+    event.outcome==='cancelled'?'Tool cancelled':'Tool error';
+}
+function exchangeDirection(event){
+  return event.kind==='tool-start'?'Client → Workspace':'Workspace → Client';
+}
+function exchangeProject(event){
+  return arr(state.overview?.projects).find(project=>project.id===event.projectId)?.name??event.projectId;
+}
+function exchangeMarkup(){
+  const {clients}=observedExchanges();
+  const selected=state.replayId?displayEvent():null;
+  const events=state.replayId?(exchangeKey(selected)?[selected]:[]):clients.slice(0,3);
+  const mode=state.replayId?'Replay':state.errors.telemetry||state.connection==='offline'?'Last loaded':'Latest';
+  const label=state.replayId?mode:mode+(clients.length?' · '+(clients.length>3?'3 of ':'')+clients.length+' client sessions':'');
+  const rows=events.map(event=>{
+    const incoming=event.kind==='tool-start';
+    const isError=!incoming&&event.outcome!=='success';
+    const host=hostName(event.agent),project=exchangeProject(event);
+    const client='<span>'+esc(host)+' <small class="muted mono" aria-label="Session suffix '+esc(event.sessionId.slice(-6))+'">'+esc(event.sessionId.slice(-6))+'</small></span>';
+    const workspace='<span class="exchange-workspace">Workspace</span>',arrow='<span class="exchange-arrow" aria-hidden="true"></span><span class="sr-only"> to </span>';
+    const route='<span class="exchange-route" title="'+esc(exchangeDirection(event)+' · '+project)+'">'+(incoming?client+arrow+workspace:workspace+arrow+client)+'</span>';
+    return '<li><button class="exchange-row" type="button" data-event="'+esc(event.id)+'" aria-pressed="'+(state.replayId===event.id)+'" title="'+esc(project+' · '+event.sessionId)+'">'+route+
+      '<span class="exchange-summary"><strong>'+esc(event.tool)+'</strong><span class="'+(isError?'red':incoming?'blue':'cyan')+'">'+exchangeLabel(event)+'</span></span><time class="mono muted" datetime="'+esc(event.timestamp)+'">'+esc(time(event.timestamp))+'</time></button></li>';
+  }).join('');
+  const message=state.replayExpired?'The selected replay record is outside the loaded history.':selected?'This event does not have a measured MCP request or result direction.':state.errors.telemetry?'The activity journal is unavailable.':
+    state.connection==='offline'?'The workspace is offline.':!state.live?'Live activity is off.':'Awaiting a measured MCP tool exchange.';
+  return '<div class="exchange-head"><h3>MCP exchanges</h3><span class="small muted">'+esc(label)+'</span></div>'+
+    (rows?list(rows,'aria-label="Observed MCP client sessions"','exchange-list'):'<p class="exchange-empty small muted">'+esc(message)+'</p>');
+}
+function updateExchanges(){
+  const container=$('graph-exchanges');
+  if(!container)return;
+  const markup=exchangeMarkup();
+  if(container.dataset.markup===markup)return;
+  const active=container.querySelector('[data-event]:focus')?.dataset.event;
+  container.innerHTML=markup;container.dataset.markup=markup;
+  if(active)[...container.querySelectorAll('[data-event]')].find(row=>row.dataset.event===active)?.focus({preventScroll:true});
+}
+function pairedExchangeMarkup(event){
+  if(!exchangeKey(event))return '';
+  const other=observedExchanges().pairs.get(event.id);
+  const isRequest=event.kind==='tool-start';
+  return '<dl class="facts">'+fact('Boundary',exchangeDirection(event))+fact('Observation',exchangeLabel(event))+fact('Project',exchangeProject(event))+'</dl>'+
+    (other?'<button class="btn quiet" type="button" data-event="'+esc(other.id)+'">'+(isRequest?'Inspect paired result':'Inspect paired request')+'</button>':
+    '<p class="small muted">'+(isRequest?'A matching result is absent from loaded records.':'A matching request is absent from loaded records.')+'</p>')+
+    '<p class="small muted">The journal records the tool boundary. Model consumption is unobserved.</p>';
+}
+`;
+//# sourceMappingURL=brain-hub-exchanges.js.map

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

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

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

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