execweave 0.8.19__tar.gz → 0.8.20__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execweave
-Version: 0.8.19
+Version: 0.8.20
 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.20}/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.20 release metadata
+version = "0.8.20"
 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.20}/src/execweave/__init__.py

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

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

@@ -8,6 +8,7 @@ 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_safety import harden_execution_flow_projection
 from .viewer_layout_v2 import inject_layout_v2
@@ -78,6 +79,7 @@ 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 = inject_edge_decross(html)
     html = harden_execution_flow_projection(inject_execution_flow(html))
     return _align_agent_panel_topology(inject_agent_panel(_guard_compact_live_snapshot(html)))
 

execweave-0.8.20/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.20}/src/execweave/viewer_execution_flow_safety.py

@@ -26,9 +26,16 @@ _TARGETED_ACTIVATION = """    const resolvedOccurrences=occurrences.filter(occur
     if(!resolvedOccurrences.length)return display;"""
 _WAIT_AWARE_ACTIVATION = """    const providerObservedEdge=edge=>{
       const evidence=attrsOf(edge);
+      const eventTypes=Array.isArray(edge?.event_types)?edge.event_types:[];
+      const backends=Array.isArray(edge?.backends)?edge.backends:[];
+      const attributions=Array.isArray(edge?.attributions)?edge.attributions:[];
+      const lifecycle=Array.isArray(edge?.provider_lifecycle)?edge.provider_lifecycle:[];
       return edge?.viewer_only===true||Boolean(
         evidence.provider||evidence.evidence_source||evidence.attribution||
-        evidence.provider_event||evidence.provider_event_type
+        evidence.provider_event||evidence.provider_event_type||
+        lifecycle.length||attributions.length||
+        backends.some(value=>String(value).toLowerCase()==='semantic')||
+        eventTypes.some(value=>String(value).toLowerCase().startsWith('semantic.'))
       );
     };
     const spawnEdges=rawEdges.filter(edge=>
@@ -92,9 +99,16 @@ _SAFE_DIRECT_ACTION_LOOP = """    for(const edge of rawEdges){
       const kind=DIRECT_ACTION_RELATIONS.get(relation(edge));
       if(!kind)continue;
       const evidence=attrsOf(edge);
+      const eventTypes=Array.isArray(edge?.event_types)?edge.event_types:[];
+      const backends=Array.isArray(edge?.backends)?edge.backends:[];
+      const attributions=Array.isArray(edge?.attributions)?edge.attributions:[];
+      const lifecycle=Array.isArray(edge?.provider_lifecycle)?edge.provider_lifecycle:[];
       const providerObserved=edge.viewer_only===true||Boolean(
         evidence.provider||evidence.evidence_source||evidence.attribution||
-        evidence.provider_event||evidence.provider_event_type
+        evidence.provider_event||evidence.provider_event_type||
+        lifecycle.length||attributions.length||
+        backends.some(value=>String(value).toLowerCase()==='semantic')||
+        eventTypes.some(value=>String(value).toLowerCase().startsWith('semantic.'))
       );
       if(!providerObserved)continue;
       const owner=agentForAnchor(edge.source),target=agentForAnchor(edge.target);

{execweave-0.8.19 → execweave-0.8.20}/src/execweave/viewer_layout_geometry.py

@@ -87,6 +87,80 @@ const execweaveGeometry=(function(){
     return{points:out,detours,obstructedGuides:points.length-guides.length};
   }
 
+  function avoidCrossings(points,boxes,segments,clearance=7){
+    const protectedSegments=(Array.isArray(segments)?segments:[]).filter(segment=>
+      segment?.a&&segment?.b&&Number.isFinite(segment.a.x)&&Number.isFinite(segment.a.y)&&
+      Number.isFinite(segment.b.x)&&Number.isFinite(segment.b.y)&&
+      Math.hypot(segment.b.x-segment.a.x,segment.b.y-segment.a.y)>epsilon
+    );
+    if(!Array.isArray(points)||points.length<2||!protectedSegments.length){
+      return{points:Array.isArray(points)?points:[],detours:0,crossingsAvoided:0};
+    }
+    const nodeBoxes=Array.isArray(boxes)?boxes:[];
+    const inside=p=>nodeBoxes.some(box=>p.x>box.x&&p.x<box.x+box.w&&p.y>box.y&&p.y<box.y+box.h);
+    const blocked=(a,b)=>nodeBoxes.some(box=>throughBox(a,b,box))||
+      protectedSegments.some(segment=>crosses(a,b,segment.a,segment.b));
+    const crossingCount=route=>{
+      let count=0;
+      for(let i=1;i<route.length;i++)for(const segment of protectedSegments)
+        if(crosses(route[i-1],route[i],segment.a,segment.b))count++;
+      return count;
+    };
+    const before=crossingCount(points);
+    if(!before)return{points,detours:0,crossingsAvoided:0};
+
+    const portals=[];
+    for(const segment of protectedSegments){
+      const dx=segment.b.x-segment.a.x,dy=segment.b.y-segment.a.y,length=Math.hypot(dx,dy);
+      if(length<=epsilon)continue;
+      const tx=dx/length,ty=dy/length,nx=-ty,ny=tx;
+      for(const endpoint of [segment.a,segment.b])for(const normal of [-1,1])for(const tangent of [-1,1]){
+        const p={
+          x:endpoint.x+normal*clearance*nx+tangent*clearance*tx,
+          y:endpoint.y+normal*clearance*ny+tangent*clearance*ty,
+        };
+        if(!inside(p))portals.push(p);
+      }
+    }
+
+    const solve=(a,b,includeBoxes)=>{
+      const vertices=[a,b,...portals];
+      if(includeBoxes){
+        for(const box of nodeBoxes){
+          const l=box.x-2,r=box.x+box.w+2,t=box.y-2,d=box.y+box.h+2;
+          for(const p of [{x:l,y:t},{x:l,y:d},{x:r,y:t},{x:r,y:d}])if(!inside(p))vertices.push(p);
+        }
+      }
+      const dist=vertices.map(()=>Infinity),prev=vertices.map(()=>-1),used=new Set();dist[0]=0;
+      for(let i=0;i<vertices.length;i++){
+        let u=-1;for(let j=0;j<vertices.length;j++)if(!used.has(j)&&(u<0||dist[j]<dist[u]))u=j;
+        if(u<0||!Number.isFinite(dist[u]))break;
+        if(u===1)break;used.add(u);
+        for(let v=0;v<vertices.length;v++){
+          if(v===u||used.has(v)||blocked(vertices[u],vertices[v]))continue;
+          const next=dist[u]+Math.hypot(vertices[u].x-vertices[v].x,vertices[u].y-vertices[v].y);
+          if(next<dist[v]-1e-6){dist[v]=next;prev[v]=u}
+        }
+      }
+      if(!Number.isFinite(dist[1]))return null;
+      const found=[];let at=1;
+      while(at>0){found.push(vertices[at]);at=prev[at]}
+      found.reverse();return found;
+    };
+
+    const out=[points[0]];let detours=0;
+    for(let part=1;part<points.length;part++){
+      const a=out[out.length-1],b=points[part];
+      const directCrosses=protectedSegments.some(segment=>crosses(a,b,segment.a,segment.b));
+      if(!directCrosses){out.push(b);continue}
+      const found=solve(a,b,false)||solve(a,b,true);
+      if(found){out.push(...found);detours++}else out.push(b);
+    }
+    const after=crossingCount(out);
+    if(after>=before)return{points,detours:0,crossingsAvoided:0};
+    return{points:out,detours,crossingsAvoided:before-after};
+  }
+
   function measure(nodes,edges){
     const routes=edges.map(e=>{const points=sample(e.d);return{...e,points,left:Math.min(...points.map(p=>p.x)),right:Math.max(...points.map(p=>p.x)),top:Math.min(...points.map(p=>p.y)),bottom:Math.max(...points.map(p=>p.y))}});
     let crossings=0,overlaps=0,intersections=0;
@@ -113,6 +187,6 @@ const execweaveGeometry=(function(){
       MAX_EDGE_LENGTH:lengths.at(-1)||0,P95_EDGE_LENGTH:lengths[Math.max(0,Math.ceil(lengths.length*.95)-1)]||0,
       VISIBLE_NODE_COUNT:nodes.length,VISIBLE_EDGE_COUNT:edges.length};
   }
-  return{polyline,sample,crosses,throughBox,measure,avoidNodes};
+  return{polyline,sample,crosses,throughBox,measure,avoidNodes,avoidCrossings};
 })();
 """.strip()