execweave 0.8.31__tar.gz → 0.8.32__tar.gz

{execweave-0.8.31 → execweave-0.8.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execweave
-Version: 0.8.31
+Version: 0.8.32
 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.31 → execweave-0.8.32}/pyproject.toml

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

{execweave-0.8.31 → execweave-0.8.32}/src/execweave/__init__.py

@@ -1,3 +1,3 @@
 """ExecWeave runtime graph package."""
 
-__version__ = "0.8.31"
+__version__ = "0.8.32"

{execweave-0.8.31 → execweave-0.8.32}/src/execweave/conversation_preview_generic.py

@@ -74,7 +74,7 @@ def _routed_agent_message(
     phase = value.get("phase")
     task_name = value.get("task_name")
     content_state = value.get("content_state")
-    return [_message(
+    message = _message(
         timestamp=timestamp,
         ordinal=ordinal,
         kind=kind if isinstance(kind, str) and kind else "agent_message",
@@ -84,7 +84,10 @@ def _routed_agent_message(
         phase=phase if isinstance(phase, str) and phase else None,
         task_name=task_name if isinstance(task_name, str) and task_name else None,
         content_state=content_state if isinstance(content_state, str) and content_state else "plaintext",
-    )]
+    )
+    if isinstance(value.get("message_id"), str):
+        message["message_id"] = value["message_id"]
+    return [message]
 
 
 def _generic_content_messages(
@@ -108,6 +111,10 @@ def _generic_content_messages(
         if routed:
             return routed
     if "model_request" in kind or "model_response" in kind or "model_failure" in kind:
+        if "model_response" in kind:
+            response = _response_messages(value, timestamp=timestamp, ordinal=ordinal, agent_path=agent_path)
+            if response:
+                return response
         structured = _structured_messages(value, timestamp=timestamp, ordinal=ordinal, agent_path=agent_path)
         if structured:
             return structured

{execweave-0.8.31 → execweave-0.8.32}/src/execweave/framework_adapters/camel.py

@@ -140,6 +140,12 @@ class CAMELAdapter(FrameworkAdapter):
             methods[name] = _callback_method(name, self)
         return type("ExecWeaveCAMELWorkforceCallback", (base,), methods)()
 
+    def observe_task_channel(self, channel: Any, *, publishers: dict[str, EntityRef]) -> Any:
+        """Record actual task dispatch/receipt and result dispatch/receipt."""
+        from .camel_channel import observe_task_channel
+
+        return observe_task_channel(self, channel, publishers)
+
     def _callback_event(self, name: str, args: tuple[Any, ...], kwargs: dict[str, Any]) -> Any:
         payload = _payload(args, kwargs)
         if name in {"log_message", "log_stream_chunk"}:

execweave-0.8.32/src/execweave/framework_adapters/camel_channel.py

@@ -0,0 +1,71 @@
+"""Observe an explicitly supplied CAMEL TaskChannel instance, not global classes."""
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from .base import EntityRef
+
+
+def observe_task_channel(adapter: Any, channel: Any, publishers: Mapping[str, EntityRef]) -> Any:
+    if getattr(channel, "_execweave_channel_adapter", None) is adapter:
+        return channel
+    names = ("post_task", "get_assigned_task_by_assignee", "return_task", "get_returned_task_by_publisher")
+    originals = {name: getattr(channel, name, None) for name in names}
+    if not all(callable(method) for method in originals.values()):
+        raise TypeError("CAMEL channel does not expose the supported task delivery boundaries")
+    routes: dict[str, dict[str, Any]] = {}
+    counter = 0
+
+    def record(route, *, reply=False, received=False):
+        source, target = route["publisher"], route["assignee"]
+        task = route["task"]
+        content = str(getattr(task, "result", "") or "") if reply else str(getattr(task, "content", "") or "")
+        if reply:
+            source, target = target, source
+        message = adapter.message(
+            route["id"] + (":reply" if reply else ":dispatch"), source, target,
+            content=content, role="agent", received=received,
+            routing_source="camel_task_channel_delivery" if received else "camel_task_channel_post",
+            native_task_id=str(task.id),
+        )
+        if source is None or target is None:
+            adapter.message_unrouted(message, callback_name="TaskChannel", missing_sender=source is None, missing_recipient=target is None)
+
+    async def post_task(task, publisher_id, assignee_id):
+        nonlocal counter
+        result = await originals["post_task"](task, publisher_id, assignee_id)
+        counter += 1
+        route = {"id": f"channel:{task.id}:{counter}", "task": task,
+                 "publisher": publishers.get(str(publisher_id)) or adapter._agents.get(str(publisher_id)),
+                 "assignee": adapter._agents.get(str(assignee_id))}
+        routes[str(task.id)] = route
+        record(route)
+        return result
+
+    async def assigned(assignee_id):
+        task = await originals["get_assigned_task_by_assignee"](assignee_id)
+        route = routes.get(str(task.id))
+        if route:
+            record(route, received=True)
+        return task
+
+    async def return_task(task_id):
+        result = await originals["return_task"](task_id)
+        route = routes.get(str(task_id))
+        if route:
+            record(route, reply=True)
+        return result
+
+    async def returned(publisher_id):
+        task = await originals["get_returned_task_by_publisher"](publisher_id)
+        route = routes.pop(str(task.id), None)
+        if route:
+            record(route, reply=True, received=True)
+        return task
+
+    channel.post_task = post_task
+    channel.get_assigned_task_by_assignee = assigned
+    channel.return_task = return_task
+    channel.get_returned_task_by_publisher = returned
+    channel._execweave_channel_adapter = adapter
+    return channel

{execweave-0.8.31 → execweave-0.8.32}/src/execweave/framework_adapters/metagpt.py

@@ -165,6 +165,8 @@ class MetaGPTAdapter(FrameworkAdapter):
         source_name = getattr(message_object, "sent_from", None)
         target_name = getattr(message_object, "send_to", None)
         source = self._roles.get(str(source_name)) if source_name else None
+        if source is None and source_name == "user":
+            source = self.entity("user", "user", name="user")
         content = _text(getattr(message_object, "content", None))
         role = _text(getattr(message_object, "role", None))
         common_attributes = {
@@ -222,6 +224,19 @@ class MetaGPTAdapter(FrameworkAdapter):
             )
         return message
 
+    def observe_message_delivery(self, message_object: Any, *, recipient: EntityRef, task: EntityRef | None = None) -> EntityRef:
+        """Call after the native Role.put_message accepted a message into its queue."""
+        self._message_counter += 1
+        return self.observe_message(
+            getattr(message_object, "id", None) or f"delivery-{self._message_counter}",
+            source=(self.entity("user", "user", name="user") if getattr(message_object, "sent_from", None) == "user"
+                    else self._roles.get(str(getattr(message_object, "sent_from", "")))),
+            target=recipient,
+            content=_text(getattr(message_object, "content", None)),
+            role=_text(getattr(message_object, "role", None)), task=task, received=True,
+            routing_source="metagpt.Role.put_message",
+        )
+
     def observe_action(
         self,
         action_id: str | int,

{execweave-0.8.31 → execweave-0.8.32}/src/execweave/viewer_agent_panel.py

@@ -15,8 +15,8 @@ _AGENT_PANEL_CSS = r"""
 #open-final{display:none!important}
 .execweave-agent-view{display:grid;gap:12px}
 .execweave-agent-card{border:1px solid var(--border);border-radius:10px;background:var(--panel2);overflow:hidden}
-.execweave-agent-label{padding:9px 11px;border-bottom:1px solid var(--border);font-size:10px;font-weight:800;letter-spacing:.07em;text-transform:uppercase;color:var(--muted)}
-.execweave-agent-body{margin:0;padding:11px 12px;white-space:pre-wrap;overflow-wrap:anywhere;font:12px/1.55 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;color:var(--text)}
+.execweave-agent-label,.execweave-communication-label{padding:9px 11px;border-bottom:1px solid var(--border);font-size:10px;font-weight:800;letter-spacing:.07em;text-transform:uppercase;color:var(--muted)}
+.execweave-agent-body,.execweave-message-body{margin:0;padding:11px 12px;white-space:pre-wrap;overflow-wrap:anywhere;font:12px/1.55 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;color:var(--text)}
 .execweave-agent-empty{color:var(--muted);font-style:italic}
 .execweave-agent-rounds{display:grid;gap:10px}
 .execweave-agent-round{display:grid;gap:12px}
@@ -28,6 +28,8 @@ _AGENT_PANEL_CSS = r"""
 .execweave-agent-older[open]>summary{border-bottom:1px solid var(--border)}
 .execweave-agent-older>.execweave-agent-round{padding:10px 11px 11px}
 .execweave-agent-when{font-variant-numeric:tabular-nums;color:var(--text)}
+.execweave-message-history{border:1px solid var(--border);border-radius:10px;background:var(--panel2);margin:6px 0}
+.execweave-message-history>summary{cursor:pointer;padding:9px 11px;font-size:11px;color:var(--muted);overflow-wrap:anywhere}
 """.strip()
 
 _AGENT_PANEL_JS = r"""
@@ -119,7 +121,7 @@ function foldStateFor(node){
 function rememberVisibleFoldState(){
   if(!selectedNode)return;
   const state=foldStateFor(selectedNode);
-  for(const fold of details.querySelectorAll('.execweave-agent-older[data-fold-key]')){
+  for(const fold of details.querySelectorAll('.execweave-agent-older[data-fold-key],.execweave-message-history[data-fold-key]')){
     const key=String(fold.dataset.foldKey||'');
     if(key)state.set(key,fold.open);
   }
@@ -348,6 +350,7 @@ function execweaveNodeCardsBase(node){
     return rows;
   }
   if(kind==='process'){
+    if(Array.isArray(a.viewer_message_evidence)&&a.viewer_message_evidence.length)add('Unrouted callback messages',`${a.viewer_message_evidence.length} observations; sender/recipient not exposed. Original evidence retained in raw graph.`);
     add('Command',a.cmdline);
     add('Executable',a.exe);
     add('Process',[a.pid&&`pid ${a.pid}`,a.ppid&&`parent ${a.ppid}`].filter(Boolean).join('  \u00b7  '));
@@ -438,8 +441,38 @@ function execweaveFillAssignedTask(round,node,isRoot){
   const value=round||{cards:[]},cards=Array.isArray(value.cards)?value.cards.map(card=>[card[0],card[1]]):[];
   const label=isRoot?'Prompt':'Task',index=cards.findIndex(card=>String(card[0]||'')===label);
   if(index<0)cards.unshift([label,task]);else if(!commandText(cards[index][1]))cards[index][1]=task;
+  else if(attrs(node).conversation_scope==='framework_agent'&&commandText(cards[index][1])!==task)cards.unshift(['Assigned task',task]);
   return{...value,cards};
 }
+function agentCommunicationHistory(node,messages){
+  // Read only this exact agent's conversation record. Never sweep sibling
+  // transcripts into the parent merely because they share a run or a model.
+  const candidates=messages.filter(message=>isObserved(message)&&!isInjected(message)&&(
+    String(message?.kind||'')==='agent_message'||
+    (String(message?.sender||'').startsWith('/')&&String(message?.recipient||'').startsWith('/')&&message.sender!==message.recipient)
+  ));
+  const byMessage=new Map();
+  for(const message of candidates){
+    const key=message.message_id?JSON.stringify([message.message_id,message.sender,message.recipient,message.text]):messageKey(message);
+    const previous=byMessage.get(key);
+    if(!previous||message.phase==='received')byMessage.set(key,message);
+  }
+  const routed=[...byMessage.values()];
+  if(!routed.length)return null;
+  const section=document.createElement('section');section.className='execweave-agent-communication';
+  section.dataset.agentId=String(node.id);
+  const title=document.createElement('div');title.className='execweave-communication-label';title.textContent='Agent communication';section.appendChild(title);
+  const state=foldStateFor(node);
+  for(const message of [...routed].reverse()){
+    const fold=document.createElement('details');fold.className='execweave-message-history';
+    const key='message:'+messageKey(message);fold.dataset.foldKey=key;fold.open=state.get(key)===true;
+    const summary=document.createElement('summary');
+    summary.textContent=[moment(message.timestamp),`${message.sender||'Unknown sender'} → ${message.recipient||'Recipient not recorded'}`].filter(Boolean).join(' · ');
+    const body=document.createElement('pre');body.className='execweave-message-body';body.textContent=displayText(message);
+    fold.append(summary,body);fold.addEventListener('toggle',()=>state.set(key,fold.open));section.appendChild(fold);
+  }
+  return section;
+}
 function renderNode(node){
   const rows=nodeCards(node);
   if(!rows.length)return false;
@@ -460,8 +493,8 @@ function render(node){
   const isRoot=nodeHasRootAuthority(node)||previewUsesRootRenderer(preview);
   const rounds=(isRoot?rootRounds(messages,path||'/root'):childRounds(messages,path)).map(round=>execweaveFillAssignedTask(round,node,isRoot));
   const tools=toolCallsFor(String(node.id||''));
-  const frameworkCommunication=attrs(node).conversation_scope==='framework_agent'?uniqueTexts(messages.filter(message=>isObserved(message)&&!isInjected(message)&&String(message?.kind||'')==='agent_message')).join('\n\n'):'';
-  const appendTools=()=>{if(frameworkCommunication)details.appendChild(card('Agent communication',frameworkCommunication));if(tools)details.appendChild(card('Tools',tools))};
+  const communication=agentCommunicationHistory(node,messages);
+  const appendTools=()=>{if(communication)details.appendChild(communication);if(tools)details.appendChild(card('Tools',tools))};
   if(rounds.length<2){const fallback={cards:isRoot?[['Prompt',''],['Final response','']]:[['Task',''],['Thinking',''],['Response','']]};details.appendChild(roundView(rounds[0]||execweaveFillAssignedTask(fallback,node,isRoot)));appendTools();return true}
   // A subagent borrows the moment and the wording of the unique canonical root round
   // it belongs to. If root identity is ambiguous, the child keeps its own timestamp.

{execweave-0.8.31 → execweave-0.8.32}/src/execweave/viewer_execution_flow.py

@@ -571,6 +571,7 @@ EXECUTION_FLOW_SCRIPT = r"""
     const ranks=[...widthByRank.keys()].sort((a,b)=>a-b);
     const minRank=ranks[0],rootItems=ranked.filter(item=>item.rank===minRank);
     let x=Math.min(...rootItems.map(item=>item.spec.x));
+    if(rootItems.some(item=>attrsOf(nodeById.get(item.id)).viewer_session_flow))x=Math.min(...[...topo.spec.values()].map(spec=>spec.x));
     if(!Number.isFinite(x))x=0;
     const xByRank=new Map();
     for(const rank of ranks){

{execweave-0.8.31 → execweave-0.8.32}/src/execweave/viewer_execution_flow_provider_normalization.py

@@ -102,4 +102,6 @@ def normalize_provider_execution_flow(html: str) -> str:
         if html.count(needle) != 1:
             raise RuntimeError(f"execution-flow provider normalization seam changed: {label}")
         html = html.replace(needle, replacement, 1)
-    return html
+    from .viewer_session_flow import inject_session_flow
+
+    return inject_session_flow(html)

{execweave-0.8.31 → execweave-0.8.32}/src/execweave/viewer_execution_flow_safety.py

@@ -123,23 +123,8 @@ _WAIT_AWARE_ACTIVATION = """    const spawnEdges=rawEdges.filter(edge=>
         if(!ended)occurrence.targets.add(child);
       }
     }
-    // The branch model answers "which model does this target agent belong to?".
-    // Prefer a unanimous target-agent model context over the actor's current model.
-    // This keeps old children under gpt-5.5 even if /root later switches to Luna.
-    for(const occurrence of occurrences){
-      if(!occurrence.targets.size)continue;
-      // Child model lookup ignores the actor tool-call/item hint. Only the child's
-      // own model evidence may win, and every target must share one known model.
-      const targetModels=[];
-      let allKnown=true;
-      for(const target of occurrence.targets){
-        const modelId=resolveModel(target,null);
-        if(!modelId){allKnown=false;break}
-        targetModels.push(modelId);
-      }
-      const unique=new Set(targetModels);
-      if(allKnown&&unique.size===1)occurrence.modelId=[...unique][0];
-    }
+    // Actions belong to the actor's model at the time of the action. A child's
+    // model never changes the model that issued a delegation, message, or wait.
     const resolvedOccurrences=occurrences.filter(occurrence=>occurrence.targets.size>0);
     if(!resolvedOccurrences.length)return display;
     const flowKey=occurrence=>`${occurrence.owner}\\u0000${occurrence.kind}\\u0000${occurrence.modelId||''}`;
@@ -284,8 +269,8 @@ def harden_execution_flow_projection(html: str) -> str:
     """Fail closed on ambiguous or evidence-poor execution-flow projection.
 
     A model context is shown only for orchestration that resolves to real target agents.
-    The target agents' evidenced model context is authoritative when all resolved targets
-    agree; the actor model is only a fallback. Explicit targets are preferred.
+    The actor's evidenced model context owns the action, independently of the target's
+    model. Explicit targets are preferred.
     Target-less ``wait_agent`` calls may use the provider-evidenced active-child set:
     children spawned before the wait and without stop/close evidence before that wait.
     Exact requester -> subtask -> assigned-child chains and exact owner-bound tool-call
@@ -361,4 +346,4 @@ def harden_execution_flow_projection(html: str) -> str:
     if html.count(_FLOW_EARLY_RETURN) != 1 or html.count(_FLOW_END) != 1:
         raise RuntimeError("execution-flow final geometry seam changed")
     html = html.replace(_FLOW_EARLY_RETURN, _FLOW_SAFE_EARLY_RETURN, 1)
-    return html.replace(_FLOW_END, _FLOW_SAFE_END, 1)
+    return html.replace(_FLOW_END, _FLOW_SAFE_END, 1)

{execweave-0.8.31 → execweave-0.8.32}/src/execweave/viewer_flow_canvas.py

@@ -91,6 +91,10 @@ function execweaveFlowDisplay(data,display){
 // another one inherits that node's layer and row, and reading those back places it
 // exactly on top of the node it was copied from.
 function execweaveFlowPreference(id){
+  const projected=nodeById.get(id)?.attributes||{};
+  // The browser's session projection runs after the Python flow projection. Its
+  // explicit ranks supersede copied resource layers, including synthetic nodes.
+  if(Number.isInteger(projected.viewer_flow_rank)&&[...nodeById.values()].some(n=>n.attributes?.viewer_session_flow))return{layer:projected.viewer_flow_rank,row:0};
   const owned=execweaveFlowNodeIds();
   // A folded member is still drawn when the browser's file/type budget keeps it. Its
   // annotation carries the survivor's solved layer and row, so keep that preference;
@@ -163,6 +167,12 @@ function execweaveFlowSolve(){
   // stack, which is to say only when it closes a cycle. Every other edge is kept, so a
   // node always takes a column after the nodes that lead to it.
   const feedback=new Set(),state=new Map(ids.map(id=>[id,0]));
+  // A recorded reply remains a return even if the dispatch was outside this
+  // recording; do not move the main agent behind its received message history.
+  for(const pair of pairs){
+    const source=nodeById.get(pair.source),target=nodeById.get(pair.target);
+    if(target?.attributes?.viewer_session_flow&&(source?.attributes?.viewer_framework_messages||source?.attributes?.viewer_return_message))feedback.add(pair.source+'|'+pair.target);
+  }
   // With a viewer_flow payload, prefer the projection's layer order when choosing the
   // DFS roots. Without one (the dashboard shell also accepts a raw static graph), keep
   // the graph's insertion order: sorting IDs would visit `agent:child:*` before
@@ -180,6 +190,7 @@ function execweaveFlowSolve(){
       const peers=after.get(frame.id);
       if(frame.next>=peers.length){state.set(frame.id,2);stack.pop();continue}
       const peer=peers[frame.next++];
+      if(feedback.has(frame.id+'|'+peer))continue;
       const seen=state.get(peer);
       if(seen===1)feedback.add(frame.id+'|'+peer);
       else if(seen===0){state.set(peer,1);stack.push({id:peer,next:0})}

execweave-0.8.32/src/execweave/viewer_framework_flow.py

@@ -0,0 +1,54 @@
+"""Framework-only communication projection. Provider graphs pass through unchanged."""
+
+FRAMEWORK_FLOW_SCRIPT = r"""
+  function execweaveFrameworkMessages(display,raw){
+    const a=n=>n?.attributes||{},r=e=>String(e?.relation||'').toUpperCase();
+    const agents=new Map((raw?.nodes||[]).filter(n=>n.type==='agent'&&a(n).conversation_scope==='framework_agent').map(n=>[n.id,n]));
+    if(!agents.size)return display;
+    const groups=new Map();
+    for(const e of raw.edges||[]){
+      if(!['MESSAGE_SENT','MESSAGE_RECEIVED'].includes(r(e))||!agents.has(e.source)||!agents.has(e.target)||e.source===e.target||e.inferred===true)continue;
+      const key=`${e.source}\0${e.target}`;
+      if(!groups.has(key))groups.set(key,{source:e.source,target:e.target,edges:[]});
+      groups.get(key).edges.push(e);
+    }
+    if(!groups.size)return display;
+    let nodes=display.nodes.map(n=>({...n,attributes:{...a(n)}}));
+    const hidden=new Set(),hiddenNodes=new Set(),added=[];
+    // Stream-only messages and callback logs remain in their owner's inspector.
+    // They are not delivery events and must not create dangling routing branches.
+    const providers=new Set([...agents.values()].map(n=>a(n).provider));
+    for(const n of raw.nodes||[]){
+      if(n.type!=='message'||!providers.has(a(n).provider))continue;
+      const anchors=(raw.edges||[]).filter(e=>(e.target===n.id&&agents.has(e.source)&&r(e)==='MESSAGE_SENT')||(e.source===n.id&&r(e)==='OBSERVED_AT_PROCESS'));
+      if(!anchors.length)continue;
+      for(const e of anchors){
+        const owner=nodes.find(x=>x.id===(e.source===n.id?e.target:e.source));
+        if(owner)owner.attributes.viewer_message_evidence=[...(a(owner).viewer_message_evidence||[]),{message_id:n.id,routing_status:'recipient_not_recorded',evidence_edge_id:e.id}];
+      }
+      hiddenNodes.add(n.id);
+    }
+    nodes=nodes.filter(n=>!hiddenNodes.has(n.id));
+    for(const group of groups.values()){
+      const id=`viewer:messages:${encodeURIComponent(group.source)}:${encodeURIComponent(group.target)}`;
+      const receiver=agents.get(group.target);
+      const evidence=group.edges.map(e=>e.id).filter(Boolean);
+      for(const eid of evidence)hidden.add(eid);
+      nodes.push({id,type:'message',name:`Messages → ${receiver.name||group.target}`,attributes:{
+        viewer_only:true,viewer_framework_messages:true,provider:a(receiver).provider,
+        sender_agent_id:group.source,recipient_agent_id:group.target,
+        viewer_message_observations:group.edges.map(e=>({relation:e.relation,count:e.count||1,first_seen:e.first_seen,last_seen:e.last_seen,evidence_edge_id:e.id})),
+        evidence_edge_ids:evidence,
+      }});
+      const delivery=group.edges.some(e=>r(e)==='MESSAGE_RECEIVED')?'DELIVERED_AGENT_MESSAGE':'ADDRESSED_TO';
+      for(const [source,target,relation] of [[group.source,id,'MESSAGE_SENT'],[id,group.target,delivery]]){
+        added.push({id:`viewer:${source}--${relation}-->${target}`,source,target,relation,count:1,viewer_only:true,causal:false,inferred:false,
+          first_sequence:Math.min(...group.edges.map(e=>e.first_sequence).filter(Number.isInteger)),
+          first_seen:group.edges.map(e=>e.first_seen).filter(Boolean).sort()[0],
+          attributes:{evidence_edge_ids:evidence,routing_basis:'framework_explicit_participants'}});
+      }
+    }
+    const edges=display.edges.filter(e=>!hidden.has(e.id)&&!hiddenNodes.has(e.source)&&!hiddenNodes.has(e.target)).concat(added);
+    return {...display,nodes,edges,node_count:nodes.length,edge_count:edges.length};
+  }
+"""

{execweave-0.8.31 → execweave-0.8.32}/src/execweave/viewer_semantic_projection.py

@@ -355,7 +355,11 @@ def collapse_framework_tasks(
                 task_id
                 for task_id, _ in sorted(
                     candidates.items(),
-                    key=lambda item: (item[1], item[0]),
+                    key=lambda item: (
+                        not bool(_attrs(node_by_id[item[0]]).get("action")),
+                        bool(_attrs(node_by_id[item[0]]).get("task_prompt") or _attrs(node_by_id[item[0]]).get("prompt")),
+                        item[1], item[0],
+                    ),
                     reverse=True,
                 )
             ]

execweave-0.8.32/src/execweave/viewer_session_flow.py

@@ -0,0 +1,166 @@
+"""Session/actor presentation over evidence; never mutates the recorded graph."""
+
+SESSION_FLOW_SCRIPT = r"""
+  function execweaveSessionFlow(display,raw){
+    const a=n=>n?.attributes||{},r=e=>String(e?.relation||'').toUpperCase();
+    const rawNodes=raw?.nodes||[],rawEdges=raw?.edges||[];
+    const byId=new Map(rawNodes.map(n=>[n.id,n]));
+    const sessions=rawNodes.filter(n=>n.type==='session');
+    // A recording can contain multiple roots/sessions. Never choose by array order.
+    const roots=rawNodes.filter(n=>n.type==='agent'&&(a(n).agent_role==='root'||a(n).viewer_root===true||a(n).agent_path==='/root'||n.name==='/root'));
+    if(!sessions.length||!roots.length)return display;
+    let nodes=display.nodes.map(n=>({...n,attributes:{...a(n),...(Number.isFinite(a(n).viewer_flow_rank)&&a(n).viewer_flow_rank>0?{viewer_flow_rank:a(n).viewer_flow_rank+1}:{})}}));
+    let edges=display.edges.map(e=>({...e}));
+    const observed=e=>e&&e.inferred!==true&&e.viewer_only!==true&&a(e).inferred!==true;
+    const unique=items=>{const ids=[...new Set(items.filter(Boolean))];return ids.length===1?ids[0]:null};
+    const ownerOf=(id,seen=new Set())=>{
+      const n=byId.get(id);if(!n||seen.has(id))return null;
+      if(n.type==='agent')return id;
+      if(!['provider_session','agent_turn','agent_execution','tool_call','tool_call_observation'].includes(n.type))return null;
+      seen=new Set(seen);seen.add(id);
+      return unique(rawEdges.filter(e=>e.target===id&&observed(e)).map(e=>ownerOf(e.source,seen)));
+    };
+    const rootSessions=new Map(),unresolved=[];
+    for(const root of roots){
+      const direct=rawEdges.filter(e=>e.source===root.id&&sessions.some(s=>s.id===e.target)&&observed(e));
+      let sid=unique(direct.map(e=>e.target));
+      // The run id is explicit recording membership, not a claim that the provider
+      // launched a process. Show that membership with a non-causal display edge.
+      if(!sid&&roots.length===1&&sessions.length===1&&sessions[0].id===`session:${raw.session_id}`)sid=sessions[0].id;
+      if(!sid){unresolved.push(root.id);continue}
+      rootSessions.set(root.id,sid);
+      const session=byId.get(sid);
+      if(!nodes.some(n=>n.id===sid))nodes.push({...session,attributes:{...a(session)}});
+      if(!edges.some(e=>e.source===root.id&&e.target===sid))edges.push({
+        id:`viewer:${root.id}--RECORDED_IN_SESSION-->${sid}`,source:root.id,target:sid,
+        relation:'RECORDED_IN_SESSION',count:1,viewer_only:true,causal:false,inferred:false,
+        attributes:{evidence_node_ids:[root.id,sid],recording_session_id:raw.session_id}
+      });
+      const sessionNode=nodes.find(n=>n.id===sid);sessionNode.attributes.viewer_flow_rank=1;
+      sessionNode.attributes.viewer_owner_agent_id=root.id;
+      const rootNode=nodes.find(n=>n.id===root.id);if(rootNode){rootNode.attributes.viewer_flow_rank=0;rootNode.attributes.viewer_session_flow=true}
+    }
+    if(!rootSessions.size)return display;
+    const modelRelations=new Set(['USED_MODEL','INVOKED_MODEL','INVOKES_MODEL','REQUESTED_MODEL','REQUESTS_MODEL_CALL','INFERRED','SWITCHED_MODEL','MODEL_INVOCATION_COMPLETED','MODEL_CALL_RESPONDS']);
+    const modelUses=[];
+    for(const e of rawEdges){
+      if(byId.get(e.target)?.type!=='model'||!modelRelations.has(r(e))||!observed(e))continue;
+      const owner=ownerOf(e.source);if(owner)modelUses.push({owner,model:e.target,edge:e});
+    }
+    const contextByKey=new Map();
+    for(const n of nodes)if(a(n).viewer_model_context)contextByKey.set(`${a(n).owner_agent_id}\0${a(n).model_resource_id}`,n.id);
+    const ensure=(owner,model)=>{
+      const key=`${owner}\0${model}`;let id=contextByKey.get(key);
+      const sid=rootSessions.get(owner);if(!sid)return id||null;
+      if(!id){
+        const resource=byId.get(model);if(!resource)return null;
+        id=`viewer:model-context:${encodeURIComponent(owner)}:${encodeURIComponent(model)}`;
+        nodes.push({...resource,id,attributes:{...a(resource),viewer_only:true,viewer_model_context:true,owner_agent_id:owner,model_resource_id:model,viewer_flow_rank:2}});
+        contextByKey.set(key,id);
+      }
+      const node=nodes.find(n=>n.id===id);if(node)node.attributes.viewer_flow_rank=2;
+      edges=edges.filter(e=>!(e.source===owner&&e.target===id&&r(e)==='MODEL_CONTEXT'));
+      if(!edges.some(e=>e.source===sid&&e.target===id))edges.push({
+        id:`viewer:${sid}--MODEL_CONTEXT-->${id}`,source:sid,target:id,relation:'MODEL_CONTEXT',
+        count:1,viewer_only:true,causal:false,inferred:false,
+        attributes:{owner_agent_id:owner,model_resource_id:model,evidence_edge_ids:modelUses.filter(u=>u.owner===owner&&u.model===model).map(u=>u.edge.id)}
+      });
+      return id;
+    };
+    for(const use of modelUses)if(rootSessions.has(use.owner))ensure(use.owner,use.model);
+    for(const n of [...nodes])if(a(n).viewer_model_context&&rootSessions.has(a(n).owner_agent_id))ensure(a(n).owner_agent_id,a(n).model_resource_id);
+    // Replace only the same actor/model's invocation edge. Child usage remains
+    // independent; a shared model name cannot steal its owner or session.
+    edges=edges.filter(e=>{
+      if(!modelRelations.has(r(e)))return true;
+      const owner=ownerOf(e.source);
+      return !(rootSessions.has(owner)&&contextByKey.has(`${owner}\0${e.target}`));
+    });
+    const modelAt=(owner,item)=>{
+      const hint=a(item).model||a(item).model_name||a(item).codex_model;
+      const uses=modelUses.filter(u=>u.owner===owner&&!['MODEL_INVOCATION_COMPLETED','MODEL_CALL_RESPONDS'].includes(r(u.edge)));
+      if(hint){const matched=unique(uses.filter(u=>u.model===hint||byId.get(u.model)?.name===hint||a(byId.get(u.model)).model_name===hint).map(u=>u.model));if(matched)return matched;return null}
+      const seq=item.first_sequence,stamp=item.first_seen;
+      const points=uses.flatMap(u=>[u,...(u.edge.last_sequence!==u.edge.first_sequence||u.edge.last_seen!==u.edge.first_seen?[{...u,edge:{...u.edge,first_sequence:u.edge.last_sequence,first_seen:u.edge.last_seen}}]:[])]);
+      // An aggregated model edge may have omitted intervening switches. Without
+      // an exact model hint, do not pretend its two endpoints are a complete log.
+      if(new Set(uses.map(u=>u.model)).size>1&&uses.some(u=>u.edge.count>2&&(Number.isInteger(seq)?u.edge.first_sequence<seq&&seq<u.edge.last_sequence:u.edge.first_seen<stamp&&stamp<u.edge.last_seen)))return null;
+      const timed=points.filter(u=>Number.isInteger(seq)&&Number.isInteger(u.edge.first_sequence)?u.edge.first_sequence<=seq:stamp&&u.edge.first_seen&&u.edge.first_seen<=stamp);
+      if(!timed.length)return null;
+      timed.sort((x,y)=>Number.isInteger(seq)?(y.edge.first_sequence||0)-(x.edge.first_sequence||0):String(y.edge.first_seen).localeCompare(String(x.edge.first_seen)));
+      const best=timed[0].edge;
+      return unique(timed.filter(u=>Number.isInteger(seq)?u.edge.first_sequence===best.first_sequence:u.edge.first_seen===best.first_seen).map(u=>u.model));
+    };
+    // Split call edges by exact occurrence ownership and model. A tool resource
+    // can be shared, but its calls must never inherit another actor's model.
+    const routedEdges=[];
+    for(const e of [...edges]){
+      if(!rootSessions.has(e.source)||!['CALLED_TOOL','REQUESTED_TOOL_CALL','REQUESTS_TOOL_CALL','USES_TOOL','PERFORMED_ORCHESTRATION','MESSAGE_SENT'].includes(r(e))){routedEdges.push(e);continue}
+      const target=nodes.find(n=>n.id===e.target);if(!target){routedEdges.push(e);continue}
+      const occurrences=(e.viewer_tool_call_occurrences||a(target).viewer_tool_call_occurrences||[]).filter(o=>!o.owner_id||o.owner_id===e.source);
+      const buckets=new Map();
+      for(const item of occurrences.length?occurrences:[null]){
+        const native=item&&(item.call_ids||[]).map(id=>byId.get(id)).find(Boolean);
+        const model=modelAt(e.source,item?{...item,attributes:a(native)}:{...e,attributes:a(target)});
+        if(!buckets.has(model))buckets.set(model,[]);
+        if(item)buckets.get(model).push(item);
+      }
+      for(const [model,items] of buckets){
+        const context=model&&ensure(e.source,model);
+        const source=context||e.source;
+        routedEdges.push({...e,id:context?`viewer:${context}--${r(e)}-->${e.target}:${encodeURIComponent(e.id)}`:e.id,source,
+          ...(occurrences.length?{count:items.length,evidence_call_count:items.length,viewer_tool_call_occurrences:items}:{}),
+          ...(context?{viewer_only:true,causal:false,viewer_original_edge_id:e.id}:{}),
+          attributes:{...a(e),...(context?{model_resource_id:model}: {model_attribution:'not_observed'})}});
+      }
+    }
+    edges=routedEdges;
+    // A received message goes back to its actual recipient. The sender's model is
+    // a separate invocation, never a substitute destination for the reply.
+    for(const n of nodes){
+      if(!a(n).viewer_orchestration_action||a(n).orchestration_kind!=='send_input')continue;
+      const owner=a(n).owner_agent_id;
+      const returns=edges.filter(e=>e.source===n.id&&rootSessions.has(e.target)&&e.target!==owner);
+      if(!returns.length)continue;
+      edges=edges.map(e=>e.target===n.id&&r(e)==='PERFORMED_ORCHESTRATION'?{...e,source:owner,relation:'SENT_AGENT_MESSAGE',viewer_original_source:e.source}:e);
+      n.attributes.viewer_return_message=true;
+      delete n.attributes.viewer_flow_rank;
+    }
+    const usedIds=new Set(edges.flatMap(e=>[e.source,e.target]));
+    nodes=nodes.filter(n=>n.type!=='model'||usedIds.has(n.id));
+    const known=new Set(nodes.map(n=>n.id));
+    edges=edges.filter(e=>known.has(e.source)&&known.has(e.target));
+    // Root/session are the forward spine. Return edges remain in the graph but
+    // cannot push the root behind its children during layout.
+    const ranks=new Map([...rootSessions.keys()].map(id=>[id,0]));
+    const queue=[...ranks.keys()];
+    while(queue.length){
+      const source=queue.shift();
+      const outgoing=edges.filter(e=>e.source===source&&!rootSessions.has(e.target));
+      outgoing.sort((x,y)=>(r(x)==='MODEL_CONTEXT'?-1:0)-(r(y)==='MODEL_CONTEXT'?-1:0));
+      for(const e of outgoing){
+        if(ranks.has(e.target))continue;
+        ranks.set(e.target,ranks.get(source)+1);queue.push(e.target);
+      }
+    }
+    for(const n of nodes){
+      if(ranks.has(n.id))n.attributes.viewer_flow_rank=ranks.get(n.id);
+      else if(n.type==='agent')n.attributes.viewer_flow_rank=3;
+    }
+    return {...display,nodes,edges,node_count:nodes.length,edge_count:edges.length,dashboard_projection:{...display.dashboard_projection,session_flow:true,unresolved_root_sessions:unresolved}};
+  }
+  function execweaveExecutionFlowProjection(display,raw){
+    return execweaveSessionFlow(execweaveFrameworkMessages(execweaveExecutionFlowBeforeSession(display,raw),raw),raw);
+  }
+"""
+
+
+def inject_session_flow(script: str) -> str:
+    from .viewer_framework_flow import FRAMEWORK_FLOW_SCRIPT
+
+    seam = "  function execweaveExecutionFlowProjection(display,raw){"
+    anchor = "  if(typeof execweaveDashboardGraph==='function'){"
+    if script.count(seam) != 1 or script.count(anchor) != 1:
+        raise RuntimeError("session flow projection seam changed")
+    script = script.replace(seam, "  function execweaveExecutionFlowBeforeSession(display,raw){", 1)
+    return script.replace(anchor, FRAMEWORK_FLOW_SCRIPT + SESSION_FLOW_SCRIPT + "\n" + anchor, 1)