roam-code 12.20__tar.gz → 12.22__tar.gz

{roam_code-12.20/src/roam_code.egg-info → roam_code-12.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roam-code
-Version: 12.20
+Version: 12.22
 Summary: Instant codebase comprehension for AI coding agents
 Author: CosmoHac
 License-Expression: MIT

{roam_code-12.20 → roam_code-12.22}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "roam-code"
-version = "12.20"
+version = "12.22"
 description = "Instant codebase comprehension for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{roam_code-12.20 → roam_code-12.22}/src/roam/commands/cmd_context.py

@@ -601,6 +601,14 @@ def _render_json(data, budget=0):
 # ---------------------------------------------------------------------------
 
 
+def _table_budget(data) -> int:
+    """Pass 118 — read the threaded ``--budget`` so format_table honors it."""
+    try:
+        return int(data.get("token_budget") or 0)
+    except (TypeError, ValueError):
+        return 0
+
+
 def _render_single_text(data):
     sym = data["sym"]
     task = data["task"]
@@ -654,7 +662,7 @@ def _render_single_text(data):
             ]
             for cr in non_test_callers[:20]
         ]
-        click.echo(format_table(["kind", "name", "location", "edge"], rows))
+        click.echo(format_table(["kind", "name", "location", "edge"], rows, budget=_table_budget(data)))
         if len(non_test_callers) > 20:
             click.echo(f"  (+{len(non_test_callers) - 20} more)")
         click.echo()
@@ -674,7 +682,7 @@ def _render_single_text(data):
             ]
             for ce in callees[:15]
         ]
-        click.echo(format_table(["kind", "name", "location", "edge"], rows))
+        click.echo(format_table(["kind", "name", "location", "edge"], rows, budget=_table_budget(data)))
         if len(callees) > 15:
             click.echo(f"  (+{len(callees) - 15} more)")
         click.echo()
@@ -1263,4 +1271,7 @@ def context(ctx, names, task, for_file, session_hint, recent_symbols, no_propaga
     # Pass 67 — pass inline-mode flag through to the renderer.
     if inline_mode:
         data["inline_mode"] = True
+    # Pass 118 — thread the global --budget through to renderers so
+    # format_table calls in cmd_context can honor it.
+    data["token_budget"] = token_budget
     _render_json(data, budget=token_budget) if json_mode else _render_text(data)

{roam_code-12.20 → roam_code-12.22}/src/roam/commands/cmd_impact.py

@@ -191,11 +191,30 @@ def impact(ctx, name, hops):
 
         G = build_symbol_graph(conn)
         if sym_id not in G:
-            click.echo(
-                f"Symbol '{name}' exists in the index but is not in the dependency graph.\n"
-                f"  Tip: Run `roam index` to rebuild the graph, or use `roam symbol {name}`"
-                " to view raw symbol data."
-            )
+            verdict = f"Symbol '{name}' exists in the index but is not in the dependency graph."
+            tip = f"Run `roam index` to rebuild the graph, or use `roam symbol {name}` to view raw symbol data."
+            if json_mode:
+                click.echo(
+                    to_json(
+                        json_envelope(
+                            "impact",
+                            budget=token_budget,
+                            summary={
+                                "verdict": verdict,
+                                "affected_symbols": 0,
+                                "affected_files": 0,
+                                "in_graph": False,
+                            },
+                            symbol=sym["qualified_name"] or sym["name"],
+                            tip=tip,
+                            direct_dependents={},
+                            affected_file_list=[],
+                            indirect_refs=[],
+                        )
+                    )
+                )
+            else:
+                click.echo(f"{verdict}\n  Tip: {tip}")
             return
 
         RG = G.reverse()

{roam_code-12.20 → roam_code-12.22}/src/roam/commands/cmd_sbom.py

@@ -47,87 +47,103 @@ def _normalize_dep_name(name: str) -> str:
     return name.lower().replace("-", "_").replace(".", "_")
 
 
+def _node_match_keys(data) -> tuple[str, str, str]:
+    """Pass 114 — pre-normalise the three node fields used for dep matching."""
+    qname = (data.get("qualified_name") or "").lower().replace("-", "_").replace(".", "_")
+    name_lower = (data.get("name") or "").lower().replace("-", "_").replace(".", "_")
+    file_path = (data.get("file_path") or "").lower().replace("-", "_").replace(".", "_")
+    return qname, name_lower, file_path
+
+
+def _matches_dep(qname: str, name_lower: str, file_path: str, norm: str) -> bool:
+    """Pass 114 — predicate version of the inner dep-match check."""
+    if qname and (qname.startswith(norm + "_") or qname.startswith(norm + "/") or qname == norm):
+        return True
+    if norm in file_path:
+        return True
+    if name_lower == norm:
+        return True
+    return False
+
+
+def _trace_entry_reach(G, entries, nid):
+    """Pass 114 — return the entry-point node IDs that can reach ``nid``."""
+    import networkx as nx
+
+    reach: list = []
+    for eid in entries:
+        try:
+            if nx.has_path(G, eid, nid):
+                reach.append(eid)
+        except (nx.NetworkXError, nx.NodeNotFound):
+            continue
+    return reach
+
+
+def _build_norm_lookup(dep_names: list[str]) -> dict[str, list[str]]:
+    """Pass 114 — group orig dep names by their normalised key."""
+    norm_to_dep: dict[str, list[str]] = {}
+    for dep in dep_names:
+        norm = _normalize_dep_name(dep)
+        if norm:
+            norm_to_dep.setdefault(norm, []).append(dep)
+    return norm_to_dep
+
+
+def _record_match(info: dict, display_name: str, G, entries, nid) -> None:
+    """Pass 114 — update a single dep's reachability record."""
+    if display_name not in info["matched_symbols"]:
+        info["matched_symbols"].append(display_name)
+    if info["reachable"]:
+        return
+    for eid in _trace_entry_reach(G, entries, nid):
+        info["reachable"] = True
+        entry_name = G.nodes[eid].get("qualified_name") or G.nodes[eid].get("name", str(eid))
+        if entry_name not in info["entry_points"]:
+            info["entry_points"].append(entry_name)
+
+
 def _compute_reachability(conn, dep_names: list[str]) -> dict[str, dict]:
     """Check which dependencies are referenced in the codebase symbol graph.
 
-    For each dependency, look for import references or qualified-name matches
-    in the ``edges`` / ``symbols`` tables.  When a match is found, trace
-    entry points (in-degree 0) that can reach the matched symbol.
+    For each dependency, look for import references or qualified-name
+    matches in the ``edges`` / ``symbols`` tables. When a match is
+    found, trace entry points (in-degree 0) that can reach the matched
+    symbol.
 
-    Returns ``{dep_name: {"reachable": bool, "entry_points": [str, ...], "matched_symbols": [str, ...]}}``
-    """
-    import networkx as nx
+    Returns ``{dep_name: {"reachable": bool, "entry_points": [...],
+    "matched_symbols": [...]}}``.
 
+    Pass 114 — orchestrator only. Pre-Pass 114 this function had cc=150
+    and nesting depth 8 (the deepest in the repo). Per-symbol logic now
+    lives in ``_node_match_keys``, ``_matches_dep``,
+    ``_trace_entry_reach``, ``_build_norm_lookup``, ``_record_match``.
+    """
     from roam.graph.builder import build_symbol_graph
 
-    result: dict[str, dict] = {}
-
-    # Pre-populate with defaults
-    for dep in dep_names:
-        result[dep] = {"reachable": False, "entry_points": [], "matched_symbols": []}
-
+    result: dict[str, dict] = {
+        dep: {"reachable": False, "entry_points": [], "matched_symbols": []} for dep in dep_names
+    }
     if not dep_names:
         return result
-
-    # Build graph once
     try:
         G = build_symbol_graph(conn)
     except Exception:
         return result
-
     if not G.nodes:
         return result
 
-    # Compute entry points (in-degree 0)
     entries = [n for n in G.nodes() if G.in_degree(n) == 0]
+    norm_to_dep = _build_norm_lookup(dep_names)
 
-    # Build a lookup: normalized name fragment -> list of node IDs
-    # We match dependency names against import targets and qualified names.
-    norm_to_dep: dict[str, list[str]] = {}
-    for dep in dep_names:
-        norm = _normalize_dep_name(dep)
-        if norm:
-            norm_to_dep.setdefault(norm, []).append(dep)
-
-    # Scan symbols for matches
     for nid, data in G.nodes(data=True):
-        qname = (data.get("qualified_name") or "").lower().replace("-", "_").replace(".", "_")
-        name_lower = (data.get("name") or "").lower().replace("-", "_").replace(".", "_")
-        file_path = (data.get("file_path") or "").lower().replace("-", "_").replace(".", "_")
-
+        qname, name_lower, file_path = _node_match_keys(data)
         for norm, orig_deps in norm_to_dep.items():
-            # Match if the normalized dep name appears as a prefix in qualified
-            # name, or in the file path (e.g., node_modules/lodash/...).
-            matched = False
-            if qname and (qname.startswith(norm + "_") or qname.startswith(norm + "/") or qname == norm):
-                matched = True
-            elif norm in file_path:
-                matched = True
-            elif name_lower == norm:
-                matched = True
-
-            if not matched:
+            if not _matches_dep(qname, name_lower, file_path, norm):
                 continue
-
             display_name = data.get("qualified_name") or data.get("name", str(nid))
-
             for dep_name in orig_deps:
-                info = result[dep_name]
-                if display_name not in info["matched_symbols"]:
-                    info["matched_symbols"].append(display_name)
-
-                if not info["reachable"]:
-                    # Check if any entry point can reach this node
-                    for eid in entries:
-                        try:
-                            if nx.has_path(G, eid, nid):
-                                info["reachable"] = True
-                                entry_name = G.nodes[eid].get("qualified_name") or G.nodes[eid].get("name", str(eid))
-                                if entry_name not in info["entry_points"]:
-                                    info["entry_points"].append(entry_name)
-                        except (nx.NetworkXError, nx.NodeNotFound):
-                            continue
-
+                _record_match(result[dep_name], display_name, G, entries, nid)
     return result
 
 

{roam_code-12.20 → roam_code-12.22}/src/roam/commands/cmd_watch.py

@@ -454,6 +454,76 @@ class DebounceAccumulator:
         return result
 
 
+def _need_force(webhook_events: list, webhook_force: bool) -> bool:
+    """Pass 115 — does the current event batch require a forced re-index?"""
+    has_explicit = any(bool(evt.get("force")) for evt in webhook_events if isinstance(evt, dict))
+    return has_explicit or (webhook_force and bool(webhook_events))
+
+
+def _scan_disk_changes(_discover, project_root: Path, tracked: dict, quiet: bool):
+    """Pass 115 — discover + diff disk state, optionally print per-file lines."""
+    current_paths = _discover()
+    current_disk = scan_disk_mtimes(current_paths, project_root)
+    added, modified, removed = detect_changes(tracked, current_disk)
+    changed = added + modified + removed
+    if changed and not quiet:
+        for path in added:
+            click.echo(f"  + {path}")
+        for path in modified:
+            click.echo(f"  ~ {path}")
+        for path in removed:
+            click.echo(f"  - {path}")
+    return tracked, changed
+
+
+def _label_webhook_events(webhook_events: list, quiet: bool) -> list[str]:
+    """Pass 115 — turn webhook event dicts into ``<webhook:name>`` labels."""
+    if not webhook_events:
+        return []
+    labels = [
+        f"<webhook:{str(evt.get('event', 'webhook')).strip() or 'webhook'}>"
+        for evt in webhook_events
+        if isinstance(evt, dict)
+    ]
+    if labels and not quiet:
+        for label in labels:
+            click.echo(f"  * {label}")
+    return labels
+
+
+def _refresh_tracked_after_reindex(project_root: Path, prev_file_count: int, quiet: bool):
+    """Pass 115 — reload tracked-files state and emit a status line."""
+    tracked = load_tracked_files(project_root)
+    new_count = len(tracked)
+    if not quiet:
+        click.echo(f"Re-index complete. Watching {new_count} files.")
+    elif new_count != prev_file_count:
+        click.echo(f"Re-indexed. Watching {new_count} files.")
+    return tracked, new_count
+
+
+def _run_guardian_step(_guardian_collect, _guardian_write, guardian_report: str, quiet: bool) -> None:
+    """Pass 115 — collect + write a guardian snapshot, log the verdict."""
+    try:
+        payload = _guardian_collect()
+        if guardian_report:
+            _guardian_write(payload)
+        if quiet:
+            return
+        gate_state = "PASS" if payload.get("gates", {}).get("health_gate_pass") else "FAIL"
+        click.echo(
+            "Guardian: health={} trend={} drift={} ({})".format(
+                payload.get("current", {}).get("health_score", "n/a"),
+                payload.get("trend", {}).get("verdict", "n/a"),
+                payload.get("drift", {}).get("drift_files", "n/a"),
+                gate_state,
+            )
+        )
+    except Exception as exc:
+        if not quiet:
+            click.echo(f"Guardian update failed: {exc}")
+
+
 def poll_loop(
     project_root: Path,
     interval: float,
@@ -530,77 +600,28 @@ def poll_loop(
     while True:
         _sleep(interval)
 
-        changed: list[str] = []
         webhook_events = _external_events() or []
-        force_needed = any(bool(evt.get("force")) for evt in webhook_events if isinstance(evt, dict))
-        force_needed = force_needed or (webhook_force and bool(webhook_events))
-        pending_force = pending_force or force_needed
+        pending_force = pending_force or _need_force(webhook_events, webhook_force)
 
+        changed: list[str] = []
         if not webhook_only:
-            # Discover current files on disk
-            current_paths = _discover()
-            current_disk = scan_disk_mtimes(current_paths, project_root)
-
-            added, modified, removed = detect_changes(tracked, current_disk)
-            changed.extend(added + modified + removed)
-
-            if changed and not quiet:
-                for path in added:
-                    click.echo(f"  + {path}")
-                for path in modified:
-                    click.echo(f"  ~ {path}")
-                for path in removed:
-                    click.echo(f"  - {path}")
-
-        if webhook_events:
-            webhook_labels = [
-                f"<webhook:{str(evt.get('event', 'webhook')).strip() or 'webhook'}>"
-                for evt in webhook_events
-                if isinstance(evt, dict)
-            ]
-            changed.extend(webhook_labels)
-            if not quiet:
-                for label in webhook_labels:
-                    click.echo(f"  * {label}")
+            tracked, disk_changes = _scan_disk_changes(_discover, project_root, tracked, quiet)
+            changed.extend(disk_changes)
+        changed.extend(_label_webhook_events(webhook_events, quiet))
 
         if changed:
             acc.add(changed)
 
-        now = time.monotonic()
-        if acc.should_fire(now):
+        if acc.should_fire(time.monotonic()):
             batch = acc.flush()
             if not quiet:
                 mode_label = "force re-indexing" if pending_force else "re-indexing"
                 click.echo(f"Changed: {len(batch)} event(s) -- {mode_label}...")
             _reindex(force=pending_force)
             pending_force = False
-            # Refresh tracked state from DB after re-index
-            tracked = load_tracked_files(project_root)
-            new_count = len(tracked)
-            if not quiet:
-                click.echo(f"Re-index complete. Watching {new_count} files.")
-            elif new_count != file_count:
-                click.echo(f"Re-indexed. Watching {new_count} files.")
-            file_count = new_count
-
+            tracked, file_count = _refresh_tracked_after_reindex(project_root, file_count, quiet)
             if guardian or guardian_report:
-                try:
-                    guard_payload = _guardian_collect()
-                    if guardian_report:
-                        _guardian_write(guard_payload)
-                    if not quiet:
-                        gate_state = "PASS" if guard_payload.get("gates", {}).get("health_gate_pass") else "FAIL"
-                        click.echo(
-                            "Guardian: health={} trend={} drift={} ({})".format(
-                                guard_payload.get("current", {}).get("health_score", "n/a"),
-                                guard_payload.get("trend", {}).get("verdict", "n/a"),
-                                guard_payload.get("drift", {}).get("drift_files", "n/a"),
-                                gate_state,
-                            )
-                        )
-                except Exception as exc:
-                    if not quiet:
-                        click.echo(f"Guardian update failed: {exc}")
+                _run_guardian_step(_guardian_collect, _guardian_write, guardian_report, quiet)
 
 
 @click.command("watch")

{roam_code-12.20 → roam_code-12.22}/src/roam/competitor_site_data.py

@@ -1364,7 +1364,7 @@ MAP_METADATA: dict[str, dict[str, object]] = {
         "peer": True,
         "graph": "PageRank + Tarjan + Louvain + layers",
         "note": "Graph algorithms (PageRank, SCC, Louvain, Fiedler) on tree-sitter ASTs fused with git history in SQLite. 128 MCP tools, 178 CLI commands. 19 Python idiom detectors (v12.7+).",
-        "version_evaluated": "12.20",
+        "version_evaluated": "12.22",
         "repo_url": "https://github.com/Cranot/roam-code",
     },
     "CKB/CodeMCP": {

{roam_code-12.20 → roam_code-12.22}/src/roam/graph/partition.py

@@ -255,61 +255,118 @@ def _adjust_cluster_count(
     return partitions
 
 
-def _build_agent_descriptors(
-    G: nx.DiGraph,
-    conn: sqlite3.Connection,
-    partitions: list[dict[str, set[int]]],
-) -> list[dict]:
-    """Build per-agent descriptor dicts.
-
-    File ownership is determined by majority vote: each file is assigned
-    exclusively to the partition that owns the most of its symbols.
-    This guarantees no write overlap between agents.
-    """
-    # Build node -> partition index
+def _node_partition_index(partitions: list[dict[str, set[int]]]) -> dict[int, int]:
+    """Pass 120 — flatten partitions into ``{node_id: partition_index}``."""
     node_part: dict[int, int] = {}
     for idx, p in enumerate(partitions):
         for n in p["nodes"]:
             node_part[n] = idx
+    return node_part
+
 
-    # Fetch file paths for all nodes
-    all_node_ids = list(node_part.keys())
+def _fetch_node_metadata(conn: sqlite3.Connection, node_ids: list[int]):
+    """Pass 120 — load (file, name, signature) for every node in one batch."""
     node_to_file: dict[int, str] = {}
     node_to_name: dict[int, str] = {}
     node_to_sig: dict[int, str] = {}
-    if all_node_ids:
-        rows = batched_in(
-            conn,
-            "SELECT s.id, s.name, s.signature, f.path "
-            "FROM symbols s JOIN files f ON s.file_id = f.id "
-            "WHERE s.id IN ({ph})",
-            all_node_ids,
-        )
-        for r in rows:
-            node_to_file[r["id"]] = r["path"].replace("\\", "/")
-            node_to_name[r["id"]] = r["name"]
-            node_to_sig[r["id"]] = r["signature"] or r["name"]
-
-    # ── Determine exclusive file ownership by majority vote ──────
-    # Count how many symbols each partition contributes to each file
+    if not node_ids:
+        return node_to_file, node_to_name, node_to_sig
+    rows = batched_in(
+        conn,
+        "SELECT s.id, s.name, s.signature, f.path FROM symbols s JOIN files f ON s.file_id = f.id WHERE s.id IN ({ph})",
+        node_ids,
+    )
+    for r in rows:
+        node_to_file[r["id"]] = r["path"].replace("\\", "/")
+        node_to_name[r["id"]] = r["name"]
+        node_to_sig[r["id"]] = r["signature"] or r["name"]
+    return node_to_file, node_to_name, node_to_sig
+
+
+def _file_majority_owners(node_part: dict[int, int], node_to_file: dict[int, str]) -> dict[int, set[str]]:
+    """Pass 120 — assign each file exclusively to its majority-vote partition."""
     file_partition_counts: dict[str, Counter] = defaultdict(Counter)
     for n, pidx in node_part.items():
         fp = node_to_file.get(n)
         if fp:
             file_partition_counts[fp][pidx] += 1
-
-    # Assign each file to the partition with the most symbols in it
-    file_owner: dict[str, int] = {}
+    partition_write_files: dict[int, set[str]] = defaultdict(set)
     for fp, counts in file_partition_counts.items():
-        file_owner[fp] = counts.most_common(1)[0][0]
+        owner = counts.most_common(1)[0][0]
+        partition_write_files[owner].add(fp)
+    return partition_write_files
+
+
+def _read_only_files_for(
+    G, nodes: set[int], node_part: dict[int, int], node_to_file: dict[int, str], write_files: set[str]
+) -> set[str]:
+    """Pass 120 — files with cross-partition edges but not owned by this agent."""
+    read_only: set[str] = set()
+    for n in nodes:
+        for neighbour in (*G.predecessors(n), *G.successors(n)):
+            if neighbour in nodes or neighbour not in node_part:
+                continue
+            fp = node_to_file.get(neighbour)
+            if fp and fp not in write_files:
+                read_only.add(fp)
+    return read_only
+
+
+def _boundary_contracts(
+    G, nodes: set[int], node_part: dict[int, int], node_to_name: dict[int, str], node_to_sig: dict[int, str]
+) -> list[str]:
+    """Pass 120 — list cross-partition symbols this agent must not change."""
+    contracts: list[str] = []
+    seen: set[str] = set()
+    for n in nodes:
+        for neighbour in (*G.successors(n), *G.predecessors(n)):
+            if neighbour in nodes or neighbour not in node_part:
+                continue
+            name = node_to_name.get(neighbour)
+            sig = node_to_sig.get(neighbour)
+            if not (name and sig):
+                continue
+            contract = f"do NOT modify {sig} signature"
+            if contract not in seen:
+                seen.add(contract)
+                contracts.append(contract)
+    return contracts
+
+
+def _cluster_label_for(nodes: set[int], node_to_file: dict[int, str], idx: int) -> str:
+    """Pass 120 — directory-majority label, with sensible fallbacks."""
+    dirs = [os.path.dirname(node_to_file.get(n, "")).replace("\\", "/") for n in nodes if n in node_to_file]
+    counts = Counter(dirs) if dirs else Counter()
+    if not counts:
+        return f"partition-{idx + 1}"
+    label = counts.most_common(1)[0][0]
+    if not label:
+        return f"root-{idx + 1}"
+    return label.rstrip("/").rsplit("/", 1)[-1] or f"partition-{idx + 1}"
 
-    # Build per-partition write file sets (exclusive, no overlap)
-    partition_write_files: dict[int, set[str]] = defaultdict(set)
-    for fp, pidx in file_owner.items():
-        partition_write_files[pidx].add(fp)
 
-    # ── Build agent descriptors ──────────────────────────────────
-    agents = []
+def _build_agent_descriptors(
+    G: nx.DiGraph,
+    conn: sqlite3.Connection,
+    partitions: list[dict[str, set[int]]],
+) -> list[dict]:
+    """Build per-agent descriptor dicts.
+
+    Pass 120 — orchestrator only. Per-step logic lives in
+    ``_node_partition_index``, ``_fetch_node_metadata``,
+    ``_file_majority_owners``, ``_read_only_files_for``,
+    ``_boundary_contracts``, ``_cluster_label_for``.
+    Cognitive complexity dropped from 161 to ~10.
+
+    File ownership is determined by majority vote: each file is
+    assigned exclusively to the partition that owns the most of its
+    symbols. This guarantees no write overlap between agents.
+    """
+    node_part = _node_partition_index(partitions)
+    node_to_file, node_to_name, node_to_sig = _fetch_node_metadata(conn, list(node_part.keys()))
+    partition_write_files = _file_majority_owners(node_part, node_to_file)
+
+    agents: list[dict] = []
     for idx, p in enumerate(partitions):
         nodes = p["nodes"]
         if not nodes:
@@ -324,66 +381,19 @@ def _build_agent_descriptors(
                 }
             )
             continue
-
-        write_files_set = partition_write_files.get(idx, set())
-
-        # Read-only files: files with edges into/from this partition
-        # but owned by another partition
-        read_only_set: set[str] = set()
-        for n in nodes:
-            for pred in G.predecessors(n):
-                if pred not in nodes and pred in node_part:
-                    fp = node_to_file.get(pred)
-                    if fp and fp not in write_files_set:
-                        read_only_set.add(fp)
-            for succ in G.successors(n):
-                if succ not in nodes and succ in node_part:
-                    fp = node_to_file.get(succ)
-                    if fp and fp not in write_files_set:
-                        read_only_set.add(fp)
-
-        # Contracts: symbols at boundaries that this agent must NOT modify
-        contracts = []
-        for n in nodes:
-            for succ in G.successors(n):
-                if succ not in nodes and succ in node_part:
-                    name = node_to_name.get(succ)
-                    sig = node_to_sig.get(succ)
-                    if name and sig:
-                        contract = f"do NOT modify {sig} signature"
-                        if contract not in contracts:
-                            contracts.append(contract)
-            for pred in G.predecessors(n):
-                if pred not in nodes and pred in node_part:
-                    name = node_to_name.get(pred)
-                    sig = node_to_sig.get(pred)
-                    if name and sig:
-                        contract = f"do NOT modify {sig} signature"
-                        if contract not in contracts:
-                            contracts.append(contract)
-
-        # Cluster label from directory majority
-        dirs = [os.path.dirname(node_to_file.get(n, "")).replace("\\", "/") for n in nodes if n in node_to_file]
-        dir_counts = Counter(dirs) if dirs else Counter()
-        if dir_counts:
-            label = dir_counts.most_common(1)[0][0]
-            label = label.rstrip("/").rsplit("/", 1)[-1] if label else f"partition-{idx + 1}"
-            if not label:
-                label = f"root-{idx + 1}"
-        else:
-            label = f"partition-{idx + 1}"
-
+        write_files = partition_write_files.get(idx, set())
+        read_only = _read_only_files_for(G, nodes, node_part, node_to_file, write_files)
+        contracts = _boundary_contracts(G, nodes, node_part, node_to_name, node_to_sig)
         agents.append(
             {
                 "id": idx + 1,
-                "write_files": sorted(write_files_set),
-                "read_only_files": sorted(read_only_set),
+                "write_files": sorted(write_files),
+                "read_only_files": sorted(read_only),
                 "symbols_owned": len(nodes),
-                "contracts": contracts[:10],  # cap at 10
-                "cluster_label": label,
+                "contracts": contracts[:10],
+                "cluster_label": _cluster_label_for(nodes, node_to_file, idx),
             }
         )
-
     return agents