execweave 0.8.29__tar.gz → 0.8.32__tar.gz

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

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

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execweave"
-# ExecWeave v0.8.29 release metadata
-version = "0.8.29"
+# 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.29 → execweave-0.8.32}/src/execweave/__init__.py

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

{execweave-0.8.29 → 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.29 → 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.29 → 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.29 → 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  '));
@@ -420,6 +423,8 @@ function toolOccurrenceSection(node){
 }
 function execweaveAssignedTaskText(agent){
   if(!agent||String(agent.type||'')!=='agent')return '';
+  const projected=attrs(agent),attached=projected.viewer_assigned_task_prompt||projected.viewer_assigned_task_name;
+  if(attached)return commandText(attached);
   const graph=rawGraph(),nodes=Array.isArray(graph.nodes)?graph.nodes:[],edges=Array.isArray(graph.edges)?graph.edges:[];
   const nodeMap=new Map(nodes.filter(node=>node&&node.id).map(node=>[String(node.id),node]));
   const exactAssignment=['ASSIGNED','AGENT','TASK'].join('_');
@@ -436,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;
@@ -458,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.29 → 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.29 → 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.29 → 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.29 → 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.29 → execweave-0.8.32}/src/execweave/viewer_semantic_projection.py

@@ -258,6 +258,155 @@ def orphan_audit(nodes: list[dict[str, Any]], edges: list[dict[str, Any]]) -> di
     return {"count": sum(item["count"] for item in by_type), "by_type": by_type}
 
 
+_FRAMEWORK_TASK_RELATIONS = frozenset(
+    {"ASSIGNED_TO", "TASK_CREATED", "TASK_STARTED", "TASK_UPDATED", "TASK_COMPLETED", "TASK_FAILED"}
+)
+
+
+def _framework_task_edge_score(edge: dict[str, Any]) -> tuple[int, str, str]:
+    sequence = edge.get("last_sequence")
+    if not isinstance(sequence, int) or isinstance(sequence, bool):
+        sequence = edge.get("first_sequence")
+    if not isinstance(sequence, int) or isinstance(sequence, bool):
+        sequence = -1
+    return (sequence, str(edge.get("last_seen") or edge.get("first_seen") or ""), str(edge.get("id") or ""))
+
+
+def _framework_task_text(task: dict[str, Any]) -> str:
+    attributes = _attrs(task)
+    for value in (
+        attributes.get("task_prompt"),
+        attributes.get("prompt"),
+        attributes.get("description"),
+        task.get("name"),
+    ):
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return ""
+
+
+def collapse_framework_tasks(
+    nodes: list[dict[str, Any]],
+    edges: list[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]], dict[str, int]]:
+    """Fold framework task presentation into the owning agent, like provider views.
+
+    Framework adapters retain first-class task entities in the raw graph because task
+    lifecycle and prompt evidence must remain auditable.  Provider dashboards expose
+    that same information on the agent card, however, so the viewer projection hides
+    only framework task nodes and copies the latest authoritative task text onto each
+    assigned framework agent.  Provider graphs are untouched because they do not use
+    the framework-agent conversation scope.
+    """
+    node_by_id = {
+        str(node["id"]): node
+        for node in nodes
+        if isinstance(node, dict) and isinstance(node.get("id"), str)
+    }
+    framework_agents = {
+        node_id
+        for node_id, node in node_by_id.items()
+        if node.get("type") == "agent" and _attrs(node).get("conversation_scope") == "framework_agent"
+    }
+    if not framework_agents:
+        return nodes, edges, {
+            "framework_task_node_count": 0,
+            "framework_task_content_node_count": 0,
+            "framework_task_agent_count": 0,
+        }
+
+    task_ids: set[str] = set()
+    tasks_by_agent: dict[str, list[tuple[tuple[int, str, str], str]]] = defaultdict(list)
+    for edge in edges:
+        if not isinstance(edge, dict) or edge.get("relation") not in _FRAMEWORK_TASK_RELATIONS:
+            continue
+        source = str(edge.get("source") or "")
+        target = str(edge.get("target") or "")
+        source_node = node_by_id.get(source)
+        target_node = node_by_id.get(target)
+        task_id = source if source_node and source_node.get("type") == "task" else target if target_node and target_node.get("type") == "task" else None
+        if task_id is None:
+            continue
+        agent_id = source if source in framework_agents else target if target in framework_agents else None
+        if agent_id is None:
+            continue
+        task_ids.add(task_id)
+        tasks_by_agent[agent_id].append((_framework_task_edge_score(edge), task_id))
+
+    if not task_ids:
+        return nodes, edges, {
+            "framework_task_node_count": 0,
+            "framework_task_content_node_count": 0,
+            "framework_task_agent_count": 0,
+        }
+
+    projected_nodes: list[dict[str, Any]] = []
+    for node in nodes:
+        node_id = str(node.get("id") or "")
+        if node_id in task_ids:
+            continue
+        if node.get("type") == "agent" and node_id in framework_agents:
+            candidates: dict[str, tuple[int, str, str]] = {}
+            for score, task_id in tasks_by_agent.get(node_id, []):
+                previous = candidates.get(task_id)
+                if previous is None or score > previous:
+                    candidates[task_id] = score
+            ordered_ids = [
+                task_id
+                for task_id, _ in sorted(
+                    candidates.items(),
+                    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,
+                )
+            ]
+            latest_task = node_by_id.get(ordered_ids[0]) if ordered_ids else None
+            attributes = dict(_attrs(node))
+            attributes["viewer_assigned_task_ids"] = ordered_ids
+            attributes["viewer_assigned_task_count"] = len(ordered_ids)
+            if latest_task is not None:
+                attributes["viewer_assigned_task_id"] = str(latest_task.get("id") or "")
+                attributes["viewer_assigned_task_name"] = str(latest_task.get("name") or "")
+                task_text = _framework_task_text(latest_task)
+                if task_text:
+                    attributes["viewer_assigned_task_prompt"] = task_text
+            projected_nodes.append({**node, "attributes": attributes})
+            continue
+        projected_nodes.append(node)
+
+    hidden_content_ids: set[str] = set()
+    for node in nodes:
+        node_id = str(node.get("id") or "")
+        if node.get("type") != "observed_content" or not node_id:
+            continue
+        incident = [
+            edge
+            for edge in edges
+            if edge.get("source") == node_id or edge.get("target") == node_id
+        ]
+        if incident and all(
+            (edge.get("source") in task_ids or edge.get("target") in task_ids)
+            for edge in incident
+        ):
+            hidden_content_ids.add(node_id)
+
+    hidden_ids = task_ids | hidden_content_ids
+    projected_nodes = [node for node in projected_nodes if str(node.get("id") or "") not in hidden_content_ids]
+    projected_edges = [
+        edge
+        for edge in edges
+        if edge.get("source") not in hidden_ids and edge.get("target") not in hidden_ids
+    ]
+    return projected_nodes, projected_edges, {
+        "framework_task_node_count": len(task_ids),
+        "framework_task_content_node_count": len(hidden_content_ids),
+        "framework_task_agent_count": len(tasks_by_agent),
+    }
+
+
 def project_provider_neutral_viewer_graph(graph: dict[str, Any]) -> dict[str, Any]:
     """Provider-neutral display projection; raw graph/evidence remains unchanged."""
     from . import viewer_projection_base as base
@@ -268,6 +417,7 @@ def project_provider_neutral_viewer_graph(graph: dict[str, Any]) -> dict[str, An
     nodes = [deepcopy(n) for n in filtered.get("nodes", []) if isinstance(n, dict)]
     edges = [deepcopy(e) for e in filtered.get("edges", []) if isinstance(e, dict)]
     entries = _entries(graph)
+    nodes, edges, framework_tasks = collapse_framework_tasks(nodes, edges)
     nodes, edges, inference = collapse_inference_requests(nodes, edges, entries)
     roots, _ = _roots(nodes, entries)
     nodes, edges, files = collapse_orphan_files(nodes, edges, roots[0] if len(roots) == 1 else None)
@@ -297,6 +447,7 @@ def project_provider_neutral_viewer_graph(graph: dict[str, Any]) -> dict[str, An
         or inference["collapsed_request_count"]
         or local is not None
         or files is not None
+        or framework_tasks["framework_task_node_count"]
     )
     if not topology_changed:
         if audit["count"]:
@@ -313,6 +464,9 @@ def project_provider_neutral_viewer_graph(graph: dict[str, Any]) -> dict[str, An
         "orphan_file_node_count": len(files.get("nodes") or []) if files else 0,
         "inference_request_count": inference["collapsed_request_count"], "logical_inference_count": inference["logical_inference_count"],
         "direct_inference_edge_count": inference["direct_inference_edge_count"], "unresolved_inference_requests": inference["unresolved"],
+        "framework_task_node_count": framework_tasks["framework_task_node_count"],
+        "framework_task_content_node_count": framework_tasks["framework_task_content_node_count"],
+        "framework_task_agent_count": framework_tasks["framework_task_agent_count"],
         "internal_hook_node_count": len(hook_nodes), "internal_hook_edge_count": len(hook_edges),
         "projection_topology_changed": True,
     })