fix(graph): preserve filtered layout contracts

Author: Coding-Dev-Tools

CHANGELOG.md

@@ -25,6 +25,9 @@ Follow-up audit of the graph, Team / Pro / licensing, and relay surfaces after 0
   before personal receipt reads, so the deployment service account remains available for
   shared automation without bypassing personal-folder ownership. The standalone
   read-only graph endpoint also disables lazy write-on-read backfill.
+- Repository indexing now creates a first-time Team workspace through the same
+  privacy-aware path as remember/import/session writes, instead of silently creating a
+  shared, unowned folder for the authenticated user.
 
 ### Fixed
 
@@ -33,6 +36,12 @@ Follow-up audit of the graph, Team / Pro / licensing, and relay surfaces after 0
   page through every live repo-associated memory instead of clearing the bridge and
   stopping at 5,000, and Git impact parsing uses NUL-delimited paths without rewriting
   valid filename characters.
+- Graph layer predicates are applied before workspace and code-edge response caps, and an
+  explicit all-off layer selection remains empty instead of reverting to every layer.
+  Layout preset and custom link-distance changes also recompute component centers while
+  preserving the existing graph data and node objects.
+  Filter reloads also tolerate transient graph-data invalidation, so restoring layers
+  redraws the canvas instead of leaving the explorer list beside an empty graph.
 - Oversized audio/video resources are rejected before transcription begins. A blank
   `ENGRAPHIS_GRAPH_TOKEN` now correctly falls back to `ENGRAPHIS_API_TOKEN`.
 - The relay sweeps `trial_pending` rows that lapsed over a day ago. Previously a magic

engraphis/core/store.py

@@ -986,7 +986,9 @@ def edges_in_scope(self, flt: Optional[SearchFilter] = None,
         if flt and flt.repo_id:
             sql += " AND (repo_id=? OR repo_id IS NULL)" if flt.include_ancestors else " AND repo_id=?"
             params.append(flt.repo_id)
-        if flt and flt.graph_layers:
+        if flt and flt.graph_layers is not None:
+            if not flt.graph_layers:
+                return []
             marks = ",".join("?" for _ in flt.graph_layers)
             sql += f" AND layer IN ({marks})"
             params.extend(_enum(layer) for layer in flt.graph_layers)
@@ -1165,9 +1167,17 @@ def list_symbols_page(self, repo_id: str, *,
         params.append(max(1, int(limit)))
         return [dict(row) for row in self.conn.execute(sql, params).fetchall()]
 
-    def list_code_edges(self, repo_id: str, *, limit: Optional[int] = None) -> list[dict]:
-        sql = "SELECT * FROM code_edges WHERE repo_id=? ORDER BY file, line, id"
+    def list_code_edges(self, repo_id: str, *, limit: Optional[int] = None,
+                        layers: Optional[list[GraphLayer]] = None) -> list[dict]:
+        sql = "SELECT * FROM code_edges WHERE repo_id=?"
         params: list[Any] = [repo_id]
+        if layers is not None:
+            if not layers:
+                return []
+            marks = ",".join("?" for _ in layers)
+            sql += f" AND layer IN ({marks})"
+            params.extend(_enum(layer) for layer in layers)
+        sql += " ORDER BY file, line, id"
         if limit is not None:
             sql += " LIMIT ?"
             params.append(max(0, int(limit)))  # never -1 == SQLite "unlimited"

engraphis/inspector/app.py

@@ -432,13 +432,16 @@ async def receipts_verify(workspace: str):
         return svc().verify_receipts(workspace=workspace)
 
     @app.get("/api/graph")
-    async def graph(workspace: str, limit: int = 2000, layers: str = "",
-                    include_code: bool = False, repo: Optional[str] = None):
+    async def graph(workspace: str, limit: int = 2000,
+                    layers: Optional[str] = None, include_code: bool = False,
+                    repo: Optional[str] = None):
         """Entity-relation network for the Graph tab -- same
         :meth:`MemoryService.graph` the v1-look dashboard's ``/api/graph`` calls
         (engraphis/graphdata.py), so both UIs render identical graphs and share
         the same workspace-binding isolation guard."""
-        selected = [x.strip() for x in layers.split(",") if x.strip()] if layers else None
+        selected = None if layers is None else [
+            x.strip() for x in layers.split(",") if x.strip()
+        ]
         return svc().graph(
             workspace=workspace, limit=limit, layers=selected,
             include_code=include_code, repo=repo,

engraphis/read_only_api.py

@@ -87,11 +87,13 @@ def intent_recall(req: IntentRecallRequest):
         )
 
     @app.get("/graph")
-    def graph(workspace: str, limit: int = 2_000, layers: str = "",
+    def graph(workspace: str, limit: int = 2_000, layers: Optional[str] = None,
               include_code: bool = False, repo: Optional[str] = None):
-        selected = [value.strip() for value in layers.split(",") if value.strip()]
+        selected = None if layers is None else [
+            value.strip() for value in layers.split(",") if value.strip()
+        ]
         return run(
-            svc.graph, workspace=workspace, limit=limit, layers=selected or None,
+            svc.graph, workspace=workspace, limit=limit, layers=selected,
             include_code=include_code, repo=repo, backfill=False,
         )
 

engraphis/routes/v2_api.py

@@ -1012,7 +1012,9 @@ def graph(workspace: Optional[str] = None, limit: int = 2000,
     service closes that gap.
     """
     ws = workspace or _default_ws()
-    selected = [x.strip() for x in layers.split(",") if x.strip()] if layers else None
+    selected = None if layers is None else [
+        x.strip() for x in layers.split(",") if x.strip()
+    ]
     return _run(
         service().graph, workspace=ws, limit=limit, layers=selected,
         include_code=include_code, repo=repo,

engraphis/service.py

@@ -1642,7 +1642,7 @@ def index_repo(self, *, workspace: str, repo: str, root_path: str,
         ws = self._clean_ws(workspace)
         rp = _clean_name(repo, field="repo")
         root_path = _clean_text(root_path, field="root_path", max_chars=MAX_CONTENT_CHARS)
-        wid = self.store.get_or_create_workspace(ws)
+        wid = self._get_or_create_workspace(ws)
         rid = self.store.get_or_create_repo(wid, rp)
         langs = None
         if languages:
@@ -2646,11 +2646,13 @@ def graph(self, *, workspace: str, limit: int = 2000,
                 (wid, limit)).fetchall()
         entity_rows = [dict(row) for row in ents]
         node_ids = {row["id"] for row in entity_rows}
+        selected_graph_layers = None
         selected_layers = None
-        if layers:
-            selected_layers = {
-                _enum(layer, GraphLayer, "layer").value for layer in layers
-            }
+        if layers is not None:
+            selected_graph_layers = [
+                _enum(layer, GraphLayer, "layer") for layer in layers
+            ]
+            selected_layers = {layer.value for layer in selected_graph_layers}
         # Nodes are capped at ``limit``; edges need their own cap or a large workspace
         # graph / indexed repo lets the lowest-privilege caller pull an unbounded
         # payload (the SQL fetches are LIMIT-ed too, so server-side work stays
@@ -2663,7 +2665,10 @@ def graph(self, *, workspace: str, limit: int = 2000,
                 "layer": edge.layer.value if edge.layer else "semantic",
             }
             for edge in self.store.edges_in_scope(
-                SearchFilter(workspace_id=wid), limit=edge_cap
+                SearchFilter(
+                    workspace_id=wid, graph_layers=selected_graph_layers
+                ),
+                limit=edge_cap,
             )
             if edge.src in node_ids and edge.dst in node_ids
             and (
@@ -2739,7 +2744,9 @@ def code_endpoint(value: str, file_hint: str = "") -> Optional[str]:
                         })
                     return file_nodes.get(file_name)
 
-                for edge in self.store.list_code_edges(rid, limit=edge_cap):
+                for edge in self.store.list_code_edges(
+                    rid, limit=edge_cap, layers=selected_graph_layers
+                ):
                     if len(edgs) >= edge_cap:
                         break
                     edge_layer = edge.get("layer") or "entity"

engraphis/static/index.html

@@ -1338,7 +1338,7 @@
 async function syncNow(){const b=document.getElementById('sync-btn');const s=document.getElementById('sync-status');if(b){b.disabled=true;b.textContent='Syncing…'}if(s)s.textContent='Contacting the cloud…';try{const d=await api('/sync/run',{method:'POST',headers:{'Content-Type':'application/json'},body:'{}'});const su=d.summary||{};toast('Synced — pushed '+(su.exported||0)+', '+(su.added||0)+' new from other devices','ok');await loadSyncStatus()}catch(e){toast('Sync failed: '+e.message,'err');if(b){b.disabled=false;b.textContent='Sync now'}if(s)s.textContent='Sync failed — try again.'}}
 
 /* ─── knowledge graph (force-graph + d3-force: compact defaults and selectable layouts) ─── */
-let GRAPH=null, FG=null, GRESIZE=false, GRESIZEFRAME=0, GADJ={}, GCOMPONENTS={}, GHILITE=null, GHOVERSET=null, GLABELRANK={}, GLABELBOXES=[], GDATA_CACHE=null, GACTIVE_DATA=null, GREDRAWFRAME=0, GPERF={large:false,dense:false};
+let GRAPH=null, FG=null, GRESIZE=false, GRESIZEFRAME=0, GADJ={}, GCOMPONENTS={}, GCOMPONENT_LAYOUT=null, GHILITE=null, GHOVERSET=null, GLABELRANK={}, GLABELBOXES=[], GDATA_CACHE=null, GACTIVE_DATA=null, GREDRAWFRAME=0, GPERF={large:false,dense:false};
 const GRAPH_PRESETS={
  original:{label:'Original force',repel:120,link:30,gravity:14,font:13,size:5,linkw:1,labelDensity:40,curve:0,particles:0},
  compact:{label:'Compact clusters',repel:42,link:20,gravity:26,font:12,size:5,linkw:.7,labelDensity:30,curve:.08,particles:0},
@@ -1414,7 +1414,7 @@
  if(count&&data)count.textContent=data.nodes.length.toLocaleString()+' entities · '+data.links.length.toLocaleString()+' relations';
  if(badge)badge.textContent=GPERF.large?'Large graph mode':'Adaptive rendering';
 }
-function graphInvalidateData(){GDATA_CACHE=null;GACTIVE_DATA=null;GHILITE=null;GHOVERSET=null}
+function graphInvalidateData(){GDATA_CACHE=null;GACTIVE_DATA=null;GCOMPONENT_LAYOUT=null;GHILITE=null;GHOVERSET=null}
 async function loadGraph(){
  graphInjectCss();graphInvalidateData();GRAPH=null;
  const empty=document.getElementById('graph-empty'),net=document.getElementById('graph-net'),nodesBox=document.getElementById('graph-entity-list'),edgesBox=document.getElementById('graph-relation-list');
@@ -1428,9 +1428,9 @@
    GRESIZEFRAME=requestAnimationFrame(()=>{GRESIZEFRAME=0;const element=document.getElementById('graph-net');if(FG&&element)FG.width(element.clientWidth).height(element.clientHeight)});
   });
  }
- const layers=Array.from(document.querySelectorAll('#graph-layer-filters input:checked')).map(input=>input.value).join(','),includeCode=document.getElementById('graph-include-code').checked,repo=(document.getElementById('graph-repo-filter').value||'').trim();
+ const layerInputs=Array.from(document.querySelectorAll('#graph-layer-filters input')),selectedLayers=layerInputs.filter(input=>input.checked).map(input=>input.value),layerFilter=selectedLayers.length===layerInputs.length?'':'&layers='+encodeURIComponent(selectedLayers.join(',')),includeCode=document.getElementById('graph-include-code').checked,repo=(document.getElementById('graph-repo-filter').value||'').trim();
  try{
-  GRAPH=await api('/graph?workspace='+encodeURIComponent(WS||'')+'&layers='+encodeURIComponent(layers)+'&include_code='+(includeCode?'true':'false')+(repo?'&repo='+encodeURIComponent(repo):''));
+  GRAPH=await api('/graph?workspace='+encodeURIComponent(WS||'')+layerFilter+'&include_code='+(includeCode?'true':'false')+(repo?'&repo='+encodeURIComponent(repo):''));
   renderGraphSide();graphRender();
  }catch(error){
   empty.style.display='flex';empty.textContent='Graph failed: '+error.message;graphSetLayoutStatus('Load failed',false);
@@ -1472,6 +1472,11 @@
   ids.forEach(id=>{GCOMPONENTS[id]={index,size:ids.length,x,y}});
  });
 }
+function graphRefreshComponentCenters(nodes,force=false){
+ const layout=window.GSET.mode+'|'+window.GSET.link;
+ if(!force&&GCOMPONENT_LAYOUT===layout)return;
+ graphIndexComponents(nodes);GCOMPONENT_LAYOUT=layout;
+}
 function graphAlpha(color,alpha){
  const hex=/^#([0-9a-f]{6})$/i.exec(color||'');
  if(hex){const value=parseInt(hex[1],16);return `rgba(${value>>16},${(value>>8)&255},${value&255},${alpha})`}
@@ -1523,9 +1528,9 @@
  GPERF={large:data.nodes.length>600||data.links.length>2400,dense:data.links.length>1500};
  if(dataChanged){
   buildAdj(data.links);GLABELRANK={};data.nodes.forEach(node=>{GLABELRANK[node.id]=node.rank});GACTIVE_DATA=data;
-  graphIndexComponents(data.nodes);
  }
- graphSetHighlight(null);
+ graphRefreshComponentCenters(data.nodes,dataChanged);
+ if(dataChanged)graphSetHighlight(null);
  if(!data.nodes.length){
   empty.style.display='flex';
   empty.textContent=GRAPH.nodes.length?('No connected entities — untick "Hide unconnected" to see all '+GRAPH.nodes.length+'.'):'No entities in this workspace yet.';
@@ -1579,7 +1584,9 @@
  }else{FG.linkCanvasObjectMode(()=>undefined)}
  FG.onRenderFramePost((ctx,scale)=>{
   if(!(settings.font>0))return;
-  const nodes=GACTIVE_DATA.nodes,focus=GHOVERSET&&GHOVERSET.size>1,cap=Math.max(1,Math.round((settings.labelDensity||40)*Math.max(.32,scale-.85))),fontSize=settings.font/scale,boxes=GLABELBOXES,candidateLimit=Math.min(nodes.length,Math.max(72,cap*10));
+  const nodes=(GACTIVE_DATA&&GACTIVE_DATA.nodes)||[];
+  if(!nodes.length)return;
+  const focus=GHOVERSET&&GHOVERSET.size>1,cap=Math.max(1,Math.round((settings.labelDensity||40)*Math.max(.32,scale-.85))),fontSize=settings.font/scale,boxes=GLABELBOXES,candidateLimit=Math.min(nodes.length,Math.max(72,cap*10));
   boxes.length=0;
   ctx.textAlign='center';ctx.textBaseline='top';ctx.lineJoin='round';ctx.font=fontSize+'px -apple-system,Segoe UI,sans-serif';ctx.lineWidth=3/scale;ctx.strokeStyle=window.GCOL.panel;ctx.fillStyle=window.GCOL.label;
   let drawn=0;
@@ -1615,6 +1622,7 @@
  if(!FG)return;
  const layout=key==='repel'||key==='link'||key==='gravity'||key==='size';
  if(key==='size')graphRefreshNodeMetrics();
+ if(key==='link'&&GACTIVE_DATA)graphRefreshComponentCenters(GACTIVE_DATA.nodes);
  if(layout)graphApplyForces();
  if(key==='linkw'){FG.linkWidth(FG.linkWidth());FG.linkColor(FG.linkColor())}else graphRedraw();
  if(layout&&!prefersReducedMotion()){graphSetLayoutStatus('Updating layout',true);FG.d3ReheatSimulation()}

tests/test_core_store.py

@@ -222,6 +222,13 @@ def test_code_listing_helpers_honor_limit(store):
                             relation="calls", file="mod.py", line=i + 1)
     assert len(store.list_code_edges("repo_x")) == 4
     assert len(store.list_code_edges("repo_x", limit=3)) == 3
+    assert len(store.list_code_edges(
+        "repo_x", layers=[GraphLayer.ENTITY], limit=3
+    )) == 3
+    assert store.list_code_edges(
+        "repo_x", layers=[GraphLayer.CAUSAL], limit=3
+    ) == []
+    assert store.list_code_edges("repo_x", layers=[], limit=3) == []
     # list_code_files was the one sibling with no SQL limit, so engine.export_code_graph
     # had to fetch the whole repo and slice it in Python.
     for i in range(5):

tests/test_dashboard_v2.py

@@ -209,6 +209,33 @@ def handle_data(self, data):
         {"value": "shared", "checked": False},
     ]
 
+
+def test_same_graph_data_refreshes_component_centers_after_layout_changes(monkeypatch,
+                                                                          tmp_path):
+    with _client(monkeypatch, tmp_path) as c:
+        response = c.get("/")
+        assert response.status_code == 200
+
+    html = response.text
+    refresh = html[html.index("function graphRefreshComponentCenters"):
+                   html.index("function graphAlpha")]
+    render = html[html.index("function graphRender"):
+                  html.index("function graphSet(key,value)")]
+    graph_set = html[html.index("function graphSet(key,value)"):
+                     html.index("function graphApplyPreset")]
+    preset = html[html.index("function graphApplyPreset"):
+                  html.index("function graphToggleLabels")]
+
+    assert "window.GSET.mode+'|'+window.GSET.link" in refresh
+    assert "if(!force&&GCOMPONENT_LAYOUT===layout)return" in refresh
+    assert "graphIndexComponents(nodes)" in refresh
+    assert "graphRefreshComponentCenters(data.nodes,dataChanged)" in render
+    assert "if(dataChanged)FG.graphData(data)" in render
+    assert "if(dataChanged)graphSetHighlight(null)" in render
+    assert ("if(key==='link'&&GACTIVE_DATA)"
+            "graphRefreshComponentCenters(GACTIVE_DATA.nodes)" in graph_set)
+    assert "if(FG)graphRender(true,true)" in preset
+
 def test_unconfigured_remote_api_is_refused_but_loopback_is_allowed(monkeypatch, tmp_path):
     remote = ("203.0.113.8", 50000)
     with _client(monkeypatch, tmp_path, client=remote) as c:
@@ -541,13 +568,40 @@ def test_viewer_role_denied_on_governance_and_admin_routes(monkeypatch, tmp_path
         assert "admin-folder" not in names
 
 
-def test_graph_endpoint_shape(monkeypatch, tmp_path):
+def test_graph_endpoint_preserves_omitted_and_explicit_empty_layers(monkeypatch, tmp_path):
     with _client(monkeypatch, tmp_path) as c:
-        g = c.get("/api/graph?workspace=demo").json()
-        assert set(g) >= {"nodes", "edges", "types", "top", "stats"}
-        assert set(g["stats"]) >= {"entities", "edges", "connected", "isolated"}
-        ids = {n["id"] for n in g["nodes"]}
-        assert all(e["from"] in ids and e["to"] in ids for e in g["edges"])
+        from engraphis.routes import v2_api
+
+        svc = v2_api.service()
+        wid = svc.store.get_or_create_workspace("demo")
+        conn = svc.store.conn
+        conn.execute(
+            "INSERT INTO entities(id, workspace_id, repo_id, name, etype, created_at) "
+            "VALUES (?,?,?,?,?,0)",
+            ("layer-filter-a", wid, None, "Layer filter A", "concept"),
+        )
+        conn.execute(
+            "INSERT INTO entities(id, workspace_id, repo_id, name, etype, created_at) "
+            "VALUES (?,?,?,?,?,0)",
+            ("layer-filter-b", wid, None, "Layer filter B", "concept"),
+        )
+        conn.execute(
+            "INSERT INTO edges(id, workspace_id, repo_id, src, dst, relation, layer) "
+            "VALUES (?,?,?,?,?,?,?)",
+            ("layer-filter-edge", wid, None, "layer-filter-a", "layer-filter-b",
+             "related_to", "semantic"),
+        )
+        conn.commit()
+
+        omitted = c.get("/api/graph", params={"workspace": "demo"}).json()
+        explicit_empty = c.get(
+            "/api/graph?workspace=demo&layers="
+        ).json()
+
+        assert set(omitted) >= {"nodes", "edges", "types", "top", "stats"}
+        assert set(omitted["stats"]) >= {"entities", "edges", "connected", "isolated"}
+        assert any(edge["label"] == "related_to" for edge in omitted["edges"])
+        assert explicit_empty["edges"] == []
 
 
 def test_team_seat_limit_enforcement(monkeypatch, tmp_path):

tests/test_inspector.py

@@ -94,6 +94,7 @@ def test_graph_endpoint_serves_the_same_data_as_the_dashboard():
         {"from": "e1", "to": "e2", "label": "works_at", "layer": "entity"}
     ]
     assert g["stats"] == {"entities": 2, "edges": 1, "connected": 2, "isolated": 0}
+    assert c.get("/api/graph?workspace=acme&layers=").json()["edges"] == []
 
 
 def test_graph_endpoint_rejects_workspace_outside_the_binding():