execweave 0.8.19__tar.gz → 0.8.21__tar.gz

{execweave-0.8.19 → execweave-0.8.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execweave
-Version: 0.8.19
+Version: 0.8.21
 Summary: Turn AI-agent runtime behavior into a local interactive execution graph.
 Project-URL: Homepage, https://github.com/Irish-kw/ExecWeave
 Project-URL: Repository, https://github.com/Irish-kw/ExecWeave

{execweave-0.8.19 → execweave-0.8.21}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execweave"
-# ExecWeave v0.8.19 release metadata
-version = "0.8.19"
+# ExecWeave v0.8.21 release metadata
+version = "0.8.21"
 description = "Turn AI-agent runtime behavior into a local interactive execution graph."
 readme = "README.md"
 requires-python = ">=3.10"

{execweave-0.8.19 → execweave-0.8.21}/src/execweave/__init__.py

@@ -1,3 +1,3 @@
 """ExecWeave runtime graph package."""
 
-__version__ = "0.8.19"
+__version__ = "0.8.21"

{execweave-0.8.19 → execweave-0.8.21}/src/execweave/_dashboard_shell_base.py

@@ -8,7 +8,9 @@ from .viewer_agent_panel import inject_agent_panel
 from .viewer_dashboard_clean import fold_budget_bootstrap, inject_live_dashboard_clean
 from .viewer_dashboard_focus import inject_live_dashboard_focus
 from .viewer_dashboard_pr70 import inject_pr70_dashboard_repairs
+from .viewer_edge_decross import inject_edge_decross
 from .viewer_execution_flow import inject_execution_flow
+from .viewer_execution_flow_provider_normalization import normalize_provider_execution_flow
 from .viewer_execution_flow_safety import harden_execution_flow_projection
 from .viewer_layout_v2 import inject_layout_v2
 from .viewer_layout_v2_detached import inject_layout_v2_detached_cluster_policy
@@ -78,7 +80,10 @@ def _build_dashboard_html() -> str:
     html = inject_pr70_dashboard_repairs(html)
     html = inject_layout_v2(html)
     html = inject_layout_v2_detached_cluster_policy(html)
-    html = harden_execution_flow_projection(inject_execution_flow(html))
+    html = inject_edge_decross(html)
+    html = normalize_provider_execution_flow(
+        harden_execution_flow_projection(inject_execution_flow(html))
+    )
     return _align_agent_panel_topology(inject_agent_panel(_guard_compact_live_snapshot(html)))
 
 

{execweave-0.8.19 → execweave-0.8.21}/src/execweave/antigravity_full_fidelity_collaboration_base.py

@@ -164,7 +164,13 @@ def _invoke_subagent_events(
                 relation="REQUESTED_SUBTASK",
                 source=parent,
                 target=subtask,
-                attributes={"child_identity_exposed": False},
+                attributes={
+                    "child_identity_exposed": False,
+                    # Exact requester -> provider conversation/step/subagent-index spec.
+                    # Validated ASSIGNED_AGENT_TASK still required before inventing a child.
+                    "identity_exact": True,
+                    "identity_method": "antigravity_provider_conversation_step_subagent_index",
+                },
             )
         )
         if type_name:

{execweave-0.8.19 → execweave-0.8.21}/src/execweave/cursor_delegation_base.py

@@ -134,6 +134,11 @@ def cursor_delegation_events(
     subtask = _subtask(payload, child)
     visibility = agent_trace_visibility("cursor")
     exact = {
+        # Persist the provider's exact subagent id through GraphEdge.to_dict(), not
+        # only in event-specific booleans, so the provider-neutral viewer can make
+        # the same fail-closed delegation decision from a materialized graph.
+        "identity_exact": True,
+        "identity_method": "cursor_provider_subagent_id",
         "provider_subagent_id_exact": True,
         "exact_child_agent_linkage": True,
         **visibility,

{execweave-0.8.19 → execweave-0.8.21}/src/execweave/opencode_task_linkage.py

@@ -172,6 +172,15 @@ def opencode_task_session_events(
     if isinstance(background, bool):
         attributes["background_requested"] = background
 
+    # GraphEdge deliberately persists identity_exact / identity_method while the
+    # provider-specific booleans above remain event-level evidence. Scope those
+    # generic identity claims to the task -> child assignment itself; task content
+    # edges should not inherit an unrelated identity method.
+    assignment_attributes = {
+        **attributes,
+        "identity_exact": True,
+        "identity_method": "opencode_task_tool_parent_and_child_session_ids",
+    }
     child = _agent(child_session, agent_name=agent_name, parent_session_id=parent_session)
     events: list[dict[str, Any]] = [
         {
@@ -180,7 +189,7 @@ def opencode_task_session_events(
             "relation": "ASSIGNED_AGENT_TASK",
             "source": _tool_call(current_session, call_id),
             "target": child,
-            "attributes": attributes,
+            "attributes": assignment_attributes,
         }
     ]
 

execweave-0.8.21/src/execweave/viewer_edge_decross.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+
+_STARTUP_SEAM = "applyTheme(initialTheme());applyTransform();poll();"
+
+EDGE_DECROSS_SCRIPT = r"""
+(function(){
+  if(typeof execweaveRoute!=='function'||typeof execweaveGeometry==='undefined')return;
+  const baseRoute=execweaveRoute;
+  const relation=edge=>String(edge?.relation||'').toUpperCase();
+  const nodeType=id=>String(typeof nodeById!=='undefined'?nodeById.get(id)?.type||'':'').toLowerCase();
+  const isNetworkEdge=edge=>relation(edge)==='CONNECTED_TO'||
+    nodeType(edge?.source)==='network_endpoint'||nodeType(edge?.target)==='network_endpoint';
+  const routePoints=edge=>{
+    const route=baseRoute(edge);
+    const points=route?.d?execweaveGeometry.polyline(route.d):null;
+    return{route,points};
+  };
+  const segments=points=>{
+    const result=[];
+    for(let i=1;i<(points?.length||0);i++)result.push({a:points[i-1],b:points[i]});
+    return result;
+  };
+  const crossesAny=(points,protectedSegments)=>{
+    for(let i=1;i<(points?.length||0);i++)for(const segment of protectedSegments)
+      if(execweaveGeometry.crosses(points[i-1],points[i],segment.a,segment.b))return true;
+    return false;
+  };
+
+  execweaveRoute=function(edge){
+    const {route,points}=routePoints(edge);
+    if(!route||!points||points.length<2||isNetworkEdge(edge)||route.kind==='bundle'||route.kind==='lifecycle-return')return route;
+    if(typeof edgeById==='undefined'||typeof positions==='undefined'||!execweaveTopology)return route;
+
+    const protectedSegments=[];
+    for(const peer of edgeById.values()){
+      if(edgeId(peer)===edgeId(edge)||!isNetworkEdge(peer))continue;
+      const peerPoints=routePoints(peer).points;
+      if(peerPoints?.length>=2)protectedSegments.push(...segments(peerPoints));
+    }
+    if(!protectedSegments.length||!crossesAny(points,protectedSegments))return route;
+
+    const boxes=[...positions]
+      .filter(([id])=>id!==edge.source&&id!==edge.target&&nodeById.has(id))
+      .map(([id,p])=>({
+        id,x:p.x,y:p.y,
+        w:execweaveTopology.width?.get(id)||execweaveWidthOf(id),
+        h:execweaveTopology.height?.get(id)||execweaveHeightOf(id),
+      }));
+    const detour=execweaveGeometry.avoidCrossings(points,boxes,protectedSegments,8);
+    if(!detour||detour.crossingsAvoided<=0||detour.points.length<2)return route;
+    const d=detour.points.map((point,index)=>`${index?'L':'M'} ${point.x} ${point.y}`).join(' ');
+    const label=detour.points[Math.floor(detour.points.length/2)];
+    return{
+      ...route,d,labelX:label.x,labelY:label.y-8,
+      geometryKind:'edge-decrossover',
+      edgeCrossingDetours:detour.detours,
+      protectedNetworkCrossingsAvoided:detour.crossingsAvoided,
+    };
+  };
+
+  if(typeof updateEdgeElement==='function'){
+    const updateBase=updateEdgeElement;
+    updateEdgeElement=function(edge){
+      // The existing PR70 wrapper already computes label placement and then clears
+      // it from rendered node boxes. Do not overwrite that cleared label position.
+      updateBase(edge);
+      const route=execweaveRoute(edge);
+      if(route?.geometryKind!=='edge-decrossover'||!route.d)return;
+      const els=edgeElements.get(edgeId(edge));if(!els)return;
+      // The base renderer normally sees the dynamically replaced execweaveRoute.
+      // Reapply only the path as a final authority guard; leave the label untouched.
+      els.visible.setAttribute('d',route.d);els.hit.setAttribute('d',route.d);
+      els.visible.dataset.geometryKind=route.geometryKind;
+      els.hit.dataset.geometryKind=route.geometryKind;
+    };
+  }
+
+  const renderedMetrics=()=>{
+    if(typeof positions==='undefined'||typeof edgeById==='undefined'||typeof nodeById==='undefined')return null;
+    const nodes=[...positions]
+      .filter(([id])=>nodeById.has(id))
+      .map(([id,p])=>({
+        id,x:p.x,y:p.y,
+        w:execweaveTopology?.width?.get(id)||execweaveWidthOf(id),
+        h:execweaveTopology?.height?.get(id)||execweaveHeightOf(id),
+      }));
+    const edges=[...edgeById.values()]
+      .filter(edge=>positions.has(edge.source)&&positions.has(edge.target))
+      .map(edge=>({...edge,d:execweaveRoute(edge).d}));
+    return execweaveGeometry.measure(nodes,edges);
+  };
+
+  // PR70's optimizer deliberately keeps its own pre-decrossover route family, but
+  // public metrics are a rendered-SVG diagnostic contract. Report the final paths
+  // users actually see so metric parity cannot drift after this local routing pass.
+  if(window.__execweavePr70&&typeof window.__execweavePr70.metrics==='function'){
+    const metricsBase=window.__execweavePr70.metrics.bind(window.__execweavePr70);
+    window.__execweavePr70.metrics=()=>renderedMetrics()||metricsBase();
+    window.__execweavePr70.crossingCount=()=>window.__execweavePr70.metrics().EDGE_CROSSINGS;
+  }
+
+  window.__execweaveEdgeDecross={
+    version:2,
+    routeFor:id=>{const edge=typeof edgeById!=='undefined'?edgeById.get(id):null;return edge?execweaveRoute(edge):null},
+    metrics:renderedMetrics,
+  };
+})();
+""".strip()
+
+
+def inject_edge_decross(html: str) -> str:
+    """Prefer local route detours over moving nodes across network evidence edges."""
+
+    if html.count(_STARTUP_SEAM) != 1:
+        raise RuntimeError("edge-decrossover startup seam changed")
+    return html.replace(_STARTUP_SEAM, EDGE_DECROSS_SCRIPT + "\n" + _STARTUP_SEAM, 1)

{execweave-0.8.19 → execweave-0.8.21}/src/execweave/viewer_execution_flow.py

@@ -43,17 +43,33 @@ EXECUTION_FLOW_SCRIPT = r"""
     return ACTION_ALIASES.get(text)||null;
   };
   const moment=item=>{
-    if(Number.isInteger(item?.first_sequence))return{kind:0,value:item.first_sequence};
     const attrs=attrsOf(item);
-    if(Number.isInteger(attrs.first_sequence))return{kind:0,value:attrs.first_sequence};
-    const stamp=item?.first_seen||attrs.first_seen||attrs.timestamp;
-    if(stamp)return{kind:1,value:String(stamp)};
-    return{kind:2,value:String(item?.id||'')};
+    const sequence=Number.isInteger(item?.first_sequence)?item.first_sequence
+      :(Number.isInteger(attrs.first_sequence)?attrs.first_sequence:null);
+    const stamp=item?.first_seen||attrs.first_seen||attrs.timestamp||null;
+    return{
+      sequence:sequence,
+      stamp:stamp?String(stamp):null,
+      id:String(item?.id||''),
+    };
   };
-  const momentLE=(left,right)=>{
+  const momentComparable=(left,right)=>{
     if(!left||!right)return false;
-    if(left.kind!==right.kind)return left.kind<right.kind;
-    return left.value<=right.value;
+    if(left.sequence!==null&&right.sequence!==null)return true;
+    if(left.stamp&&right.stamp)return true;
+    return false;
+  };
+  const momentLE=(left,right)=>{
+    // Only compare when both ends share a sequence or a timestamp. Mixing kinds
+    // (or comparing id fallbacks) falsely orders early actions against future switches.
+    if(!momentComparable(left,right))return false;
+    if(left.sequence!==null&&right.sequence!==null)return left.sequence<=right.sequence;
+    return String(left.stamp)<=String(right.stamp);
+  };
+  const momentEqual=(left,right)=>{
+    if(!momentComparable(left,right))return false;
+    if(left.sequence!==null&&right.sequence!==null)return left.sequence===right.sequence;
+    return String(left.stamp)===String(right.stamp);
   };
   const provider=node=>String(attrsOf(node).provider||'unknown').toLowerCase();
 
@@ -73,30 +89,58 @@ EXECUTION_FLOW_SCRIPT = r"""
       incoming.get(edge.target).push(edge);outgoing.get(edge.source).push(edge);
     }
     const aliasToAgent=new Map();
+    const rememberAlias=(alias,id)=>{
+      if(alias===undefined||alias===null)return;
+      const text=String(alias).trim();
+      if(!text)return;
+      let bucket=aliasToAgent.get(text);
+      if(!bucket){bucket=new Set();aliasToAgent.set(text,bucket)}
+      bucket.add(id);
+    };
     for(const [id,node] of agents){
       const attrs=attrsOf(node);
-      const aliases=[id,node.name,attrs.agent_id,attrs.thread_id,attrs.agent_path,attrs.child_agent_path,attrs.nickname];
-      for(const value of aliases)if(value!==undefined&&value!==null&&String(value).trim())aliasToAgent.set(String(value),id);
+      rememberAlias(id,id);
+      for(const value of [node.name,attrs.agent_id,attrs.thread_id,attrs.agent_path,attrs.child_agent_path,attrs.nickname]){
+        rememberAlias(value,id);
+      }
     }
     const resolveAgent=value=>{
       if(value===undefined||value===null)return null;
       const text=String(value);
+      // Exact canonical id always wins over alias lookup.
       if(agents.has(text))return text;
-      return aliasToAgent.get(text)||null;
+      const bucket=aliasToAgent.get(text);
+      if(!bucket||!bucket.size)return null;
+      if(bucket.size===1)return [...bucket][0];
+      // Non-unique alias: abstain rather than last-writer-wins.
+      return null;
+    };
+    const uniqueOwner=candidates=>{
+      const ids=[...new Set((candidates||[]).filter(Boolean))];
+      return ids.length===1?ids[0]:null;
     };
     const ownerForNode=node=>{
       if(!node?.id)return null;
-      for(const edge of incoming.get(node.id)||[])if(agents.has(edge.source))return edge.source;
+      const direct=[];
+      for(const edge of incoming.get(node.id)||[])if(agents.has(edge.source))direct.push(edge.source);
+      const directOwner=uniqueOwner(direct);
+      if(directOwner)return directOwner;
+      if(direct.length)return null; // ambiguous direct owners
+      const viaTurn=[];
       for(const edge of incoming.get(node.id)||[]){
         const parent=rawById.get(edge.source);
         if(parent?.type!=='agent_turn')continue;
-        for(const grand of incoming.get(parent.id)||[])if(agents.has(grand.source))return grand.source;
+        for(const grand of incoming.get(parent.id)||[])if(agents.has(grand.source))viaTurn.push(grand.source);
       }
+      const turnOwner=uniqueOwner(viaTurn);
+      if(turnOwner)return turnOwner;
+      if(viaTurn.length)return null;
       const attrs=attrsOf(node);
+      const attrOwners=[];
       for(const key of ['owner_agent_id','agent_id','source_agent_id','thread_id','agent_path']){
-        const found=resolveAgent(attrs[key]);if(found)return found;
+        const found=resolveAgent(attrs[key]);if(found)attrOwners.push(found);
       }
-      return null;
+      return uniqueOwner(attrOwners);
     };
     const agentForAnchor=id=>{
       if(agents.has(id))return id;
@@ -106,13 +150,23 @@ EXECUTION_FLOW_SCRIPT = r"""
     };
 
     const modelNameIndex=new Map();
+    const rememberModelAlias=(alias,id)=>{
+      if(alias===undefined||alias===null)return;
+      const text=String(alias).trim().toLowerCase();
+      if(!text)return;
+      let bucket=modelNameIndex.get(text);
+      if(!bucket){bucket=new Set();modelNameIndex.set(text,bucket)}
+      bucket.add(id);
+    };
     for(const [id,node] of models){
       const attrs=attrsOf(node);
-      for(const value of [id,node.name,attrs.model,attrs.model_name,attrs.native_name]){
-        if(value!==undefined&&value!==null&&String(value).trim())modelNameIndex.set(String(value).toLowerCase(),id);
+      rememberModelAlias(id,id);
+      for(const value of [node.name,attrs.model,attrs.model_name,attrs.native_name]){
+        rememberModelAlias(value,id);
       }
     }
     const modelHintFor=node=>{
+      if(!node)return null;
       const attrs=attrsOf(node);
       for(const key of ['model','model_name','codex_model','default_model','provider_model']){
         const value=attrs[key];
@@ -123,8 +177,13 @@ EXECUTION_FLOW_SCRIPT = r"""
     const modelIdFromHint=hint=>{
       if(!hint)return null;
       const lower=String(hint).toLowerCase();
-      if(modelNameIndex.has(lower))return modelNameIndex.get(lower);
-      for(const [key,id] of modelNameIndex)if(key.endsWith(lower)||lower.endsWith(key))return id;
+      // Exact canonical id first.
+      if(models.has(hint))return hint;
+      if(models.has(lower))return lower;
+      const bucket=modelNameIndex.get(lower);
+      if(!bucket||!bucket.size)return null;
+      if(bucket.size===1)return [...bucket][0];
+      // Ambiguous model name across resources: abstain (no suffix fuzzy match).
       return null;
     };
 
@@ -147,20 +206,43 @@ EXECUTION_FLOW_SCRIPT = r"""
       if(modelId)addModelEvent(owner,modelId,node);
     }
     for(const list of modelEventsByAgent.values())list.sort((a,b)=>{
-      if(a.moment.kind!==b.moment.kind)return a.moment.kind-b.moment.kind;
-      return a.moment.value<b.moment.value?-1:a.moment.value>b.moment.value?1:0;
+      // Prefer sequence when both have it; otherwise timestamp; never cross-rank kinds.
+      if(a.moment.sequence!==null&&b.moment.sequence!==null){
+        return a.moment.sequence-b.moment.sequence;
+      }
+      if(a.moment.stamp&&b.moment.stamp){
+        return String(a.moment.stamp)<String(b.moment.stamp)?-1:String(a.moment.stamp)>String(b.moment.stamp)?1:0;
+      }
+      if(a.moment.sequence!==null&&b.moment.sequence===null)return -1;
+      if(a.moment.sequence===null&&b.moment.sequence!==null)return 1;
+      return String(a.moment.id).localeCompare(String(b.moment.id));
     });
 
     const resolveModel=(owner,item)=>{
-      const hinted=modelIdFromHint(modelHintFor(item));
+      // Item hint is only for the owner/actor side. Callers that resolve a child
+      // must pass null as item so an actor tool-call model cannot pollute lookup.
+      const hinted=item?modelIdFromHint(modelHintFor(item)):null;
       if(hinted)return hinted;
       const list=modelEventsByAgent.get(owner)||[];
       if(!list.length)return null;
-      const at=moment(item);
-      let chosen=null;
-      for(const event of list)if(momentLE(event.moment,at))chosen=event.modelId;
-      if(chosen)return chosen;
-      const unique=[...new Set(list.map(event=>event.modelId))];
+      const at=moment(item||{});
+      const eligible=[];
+      for(const event of list){
+        if(!momentComparable(event.moment,at))continue;
+        if(momentLE(event.moment,at))eligible.push(event);
+      }
+      if(!eligible.length){
+        const unique=[...new Set(list.map(event=>event.modelId))];
+        return unique.length===1?unique[0]:null;
+      }
+      // Prefer the latest comparable event; if several tie at the same moment with
+      // conflicting models, abstain instead of taking array order.
+      let bestMoment=eligible[0].moment;
+      for(const event of eligible){
+        if(momentLE(bestMoment,event.moment)&&!momentEqual(bestMoment,event.moment))bestMoment=event.moment;
+      }
+      const tied=eligible.filter(event=>momentEqual(event.moment,bestMoment));
+      const unique=[...new Set(tied.map(event=>event.modelId))];
       return unique.length===1?unique[0]:null;
     };
 
@@ -180,18 +262,36 @@ EXECUTION_FLOW_SCRIPT = r"""
       if(!kind)continue;
       const sources=(incoming.get(node.id)||[]).filter(edge=>relation(edge)==='STARTED_AGENT_INTERACTION');
       const targets=(outgoing.get(node.id)||[]).filter(edge=>relation(edge)==='TARGETED_BY_AGENT_INTERACTION');
-      const owner=sources.map(edge=>agentForAnchor(edge.source)).find(Boolean);
-      const peerIds=targets.map(edge=>agentForAnchor(edge.target)).filter(Boolean);
-      if(owner)pushOccurrence(kind,owner,peerIds,node,[node.id],[...sources,...targets].map(edge=>edge.id).filter(Boolean));
+      const ownerCandidates=sources.map(edge=>agentForAnchor(edge.source));
+      const owner=uniqueOwner(ownerCandidates);
+      if(!owner)continue;
+      // Unknown endpoints keep the occurrence target-less rather than inventing uniqueness.
+      const peerIds=[];
+      let peersComplete=true;
+      for(const edge of targets){
+        const peer=agentForAnchor(edge.target);
+        if(!peer){peersComplete=false;continue}
+        peerIds.push(peer);
+      }
+      if(targets.length&&!peersComplete&&!peerIds.length)continue;
+      pushOccurrence(kind,owner,peerIds,node,[node.id],[...sources,...targets].map(edge=>edge.id).filter(Boolean));
     }
 
     for(const node of rawNodes){
       if(node?.type!=='agent_message'||!node.id)continue;
       const sent=(incoming.get(node.id)||[]).filter(edge=>relation(edge)==='SENT_AGENT_MESSAGE');
       const delivered=(outgoing.get(node.id)||[]).filter(edge=>relation(edge)==='DELIVERED_AGENT_MESSAGE');
-      const owner=sent.map(edge=>agentForAnchor(edge.source)).find(Boolean);
-      const peerIds=delivered.map(edge=>agentForAnchor(edge.target)).filter(Boolean);
-      if(owner)pushOccurrence('send_input',owner,peerIds,node,[node.id],[...sent,...delivered].map(edge=>edge.id).filter(Boolean));
+      const owner=uniqueOwner(sent.map(edge=>agentForAnchor(edge.source)));
+      if(!owner)continue;
+      const peerIds=[];
+      let peersComplete=true;
+      for(const edge of delivered){
+        const peer=agentForAnchor(edge.target);
+        if(!peer){peersComplete=false;continue}
+        peerIds.push(peer);
+      }
+      if(delivered.length&&!peersComplete&&!peerIds.length)continue;
+      pushOccurrence('send_input',owner,peerIds,node,[node.id],[...sent,...delivered].map(edge=>edge.id).filter(Boolean));
     }
 
     for(const edge of rawEdges){
@@ -293,13 +393,70 @@ EXECUTION_FLOW_SCRIPT = r"""
       for(const modelId of new Set(list.map(item=>item.modelId)))ensureContext(owner,modelId);
     }
 
-    const consumedRawNodes=new Set(),consumedRawEdges=new Set(),actionToolIds=new Set();
+    const consumedRawNodes=new Set(),consumedRawEdges=new Set(),consumedCallIds=new Set();
+    const contentRefFromNode=(contentNode,edge,direction)=>{
+      const attrs=attrsOf(contentNode);
+      const viewer=attrs.viewer_content&&typeof attrs.viewer_content==='object'?attrs.viewer_content:{};
+      return{
+        content_node_id:contentNode.id,
+        raw_node_id:contentNode.id,
+        raw_edge_id:edge?.id||null,
+        relation:edge?.relation||null,
+        direction:direction||null,
+        sha256:viewer.sha256||attrs.sha256||attrs.content_sha256||null,
+        path:viewer.safe_relative_path||attrs.path||attrs.content_path||null,
+        size_bytes:viewer.size_bytes??attrs.size_bytes??attrs.content_size_bytes??null,
+        media_type:viewer.media_type||attrs.media_type||attrs.content_media_type||null,
+        content_kind:viewer.content_kind||attrs.content_kind||contentNode.name||null,
+      };
+    };
     for(const group of groups.values()){
       const context=group.modelId?ensureContext(group.owner,group.modelId):null;
       const source=context||group.owner;
       const baseRank=agentRank.get(group.owner)||0;
       const actionRank=baseRank+(context?2:1);
       const id=`viewer:orchestration:${encodeURIComponent(group.owner)}:${encodeURIComponent(group.modelId||'unresolved')}:${group.kind}`;
+      const contentRefs=[];
+      const toolCallOccurrences=[];
+      for(const rawId of group.rawNodeIds){
+        const rawNode=rawById.get(rawId);
+        if(!rawNode)continue;
+        if(String(rawNode.type||'')==='observed_content'){
+          contentRefs.push(contentRefFromNode(rawNode,null,'node'));
+          continue;
+        }
+        for(const edge of [...(outgoing.get(rawId)||[]),...(incoming.get(rawId)||[])]){
+          const peerId=edge.source===rawId?edge.target:edge.source;
+          const peer=rawById.get(peerId);
+          if(peer?.type!=='observed_content')continue;
+          const direction=edge.source===rawId?'outgoing':'incoming';
+          const ref=contentRefFromNode(peer,edge,direction);
+          if(!contentRefs.some(item=>item.content_node_id===ref.content_node_id&&item.raw_edge_id===ref.raw_edge_id)){
+            contentRefs.push(ref);
+          }
+        }
+        if(['tool_call','tool_call_observation'].includes(String(rawNode?.type||''))){
+          consumedCallIds.add(rawId);
+          const attrs=attrsOf(rawNode);
+          let toolId=null;
+          for(const edge of outgoing.get(rawId)||[]){
+            if(relation(edge)==='USES_TOOL'||relation(edge)==='RESOLVED_TOOL'){toolId=edge.target;break}
+          }
+          toolCallOccurrences.push({
+            invocation_id:rawId,
+            owner_id:group.owner,
+            tool_id:toolId,
+            call_ids:[rawId],
+            first_sequence:Number.isInteger(rawNode.first_sequence)?rawNode.first_sequence:null,
+            last_sequence:Number.isInteger(rawNode.last_sequence)?rawNode.last_sequence:null,
+            first_seen:rawNode.first_seen||null,
+            last_seen:rawNode.last_seen||null,
+            input:attrs.arguments??attrs.args??attrs.tool_input??attrs.input??attrs.parameters??attrs.request??null,
+            output:attrs.output??attrs.result??attrs.tool_output??attrs.response??null,
+            content_references:contentRefs.filter(ref=>ref.raw_edge_id&&[...(outgoing.get(rawId)||[]),...(incoming.get(rawId)||[])].some(edge=>edge.id===ref.raw_edge_id)),
+          });
+        }
+      }
       addedNodes.push({
         id,type:'tool',name:group.kind,
         attributes:{
@@ -309,6 +466,8 @@ EXECUTION_FLOW_SCRIPT = r"""
           evidence_node_ids:[...group.rawNodeIds].sort(),evidence_edge_ids:[...group.rawEdgeIds].sort(),
           viewer_occurrence_count:group.occurrences.length,
           viewer_model_context_unresolved:!context||undefined,
+          viewer_content_references:contentRefs,
+          viewer_tool_call_occurrences:toolCallOccurrences,
         }
       });
       addedEdges.push({
@@ -326,13 +485,23 @@ EXECUTION_FLOW_SCRIPT = r"""
       }
       for(const rawId of group.rawNodeIds)consumedRawNodes.add(rawId);
       for(const rawId of group.rawEdgeIds)consumedRawEdges.add(rawId);
-      for(const rawId of group.rawNodeIds){
-        const rawNode=rawById.get(rawId);
-        if(!['tool_call','tool_call_observation'].includes(String(rawNode?.type||'')))continue;
-        for(const edge of outgoing.get(rawId)||[]){
-          if(relation(edge)==='USES_TOOL')actionToolIds.add(edge.target);
-        }
-      }
+    }
+
+    // Shared tool definitions / model resources stay unless every remaining USES_TOOL
+    // into them came from consumed calls. Consuming one owner's call must not wipe the
+    // shared definition for other owners or unresolved calls.
+    const hideToolDefs=new Set();
+    for(const [toolId,node] of [...rawById].filter(([,n])=>n?.type==='tool')){
+      const uses=(incoming.get(toolId)||[]).filter(edge=>['USES_TOOL','RESOLVED_TOOL'].includes(relation(edge)));
+      if(!uses.length)continue;
+      // Keep shared tool definitions when any live use remains: another owner's
+      // unconsumed call, an agent-direct USES_TOOL, or unresolved evidence.
+      const allConsumedCalls=uses.every(edge=>{
+        const src=rawById.get(edge.source);
+        const isCall=['tool_call','tool_call_observation'].includes(String(src?.type||''));
+        return isCall&&consumedCallIds.has(edge.source);
+      });
+      if(allConsumedCalls)hideToolDefs.add(toolId);
     }
 
     const flowNodes=display.nodes.map(node=>{
@@ -342,17 +511,25 @@ EXECUTION_FLOW_SCRIPT = r"""
 
     const modelRelation=edge=>MODEL_RELATIONS.has(relation(edge))||relation(edge)==='MODEL_CONTEXT';
     const orchestrationRelation=edge=>DIRECT_ACTION_RELATIONS.has(relation(edge));
-    let nodes=flowNodes.filter(node=>!consumedRawNodes.has(node.id)&&!actionToolIds.has(node.id));
+    let nodes=flowNodes.filter(node=>!consumedRawNodes.has(node.id)&&!hideToolDefs.has(node.id));
     let edges=display.edges.filter(edge=>{
       if(consumedRawEdges.has(edge.id))return false;
-      if(orchestrationRelation(edge)&&agents.has(edge.source)&&agents.has(edge.target))return false;
-      if(actionToolIds.has(edge.source)||actionToolIds.has(edge.target))return false;
-      if(contextifiedModels.has(edge.target)&&agents.has(edge.source)&&modelRelation(edge))return false;
+      // Keep unconsumed inferred / provider orchestration evidence. Only hide edges
+      // that were actually folded into an occurrence (tracked via consumedRawEdges).
+      if(orchestrationRelation(edge)&&agents.has(edge.source)&&agents.has(edge.target)){
+        return !consumedRawEdges.has(edge.id);
+      }
+      if(hideToolDefs.has(edge.source)||hideToolDefs.has(edge.target))return false;
+      // Only supersede an owner→model edge when THAT owner already has a viewer
+      // model-context for the same model. Other owners' shared-model usage stays.
+      if(modelRelation(edge)&&agents.has(edge.source)&&contextIds.has(contextId(edge.source,edge.target)))return false;
       return true;
     });
 
     for(const modelId of contextifiedModels){
       const remaining=edges.filter(edge=>edge.source===modelId||edge.target===modelId);
+      // Keep the raw model resource whenever any non-superseded usage remains
+      // (another owner, unresolved call, or non-agent attachment).
       if(!remaining.length)nodes=nodes.filter(node=>node.id!==modelId);
     }