system-diff 0.3.4__py3-none-any.whl → 0.4.2__py3-none-any.whl

system_diff/__init__.py

@@ -5,4 +5,4 @@
     bp = extract.extract(DirSource(Path(".")), cfg)
     svg = graph.system_svg(bp, cfg)
 """
-__version__ = "0.3.4"
+__version__ = "0.4.2"

system_diff/agent.py

@@ -18,7 +18,7 @@ import sys
 from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
-from . import activity, companion, config, design, learn
+from . import activity, agents, companion, config, design, learn
 from .compare import compare_worktree, mark_turn, turn_sha
 from .extract import Code
 from .sources import git
@@ -121,18 +121,22 @@ def on_start(root: Path, payload: Dict[str, Any], env=os.environ) -> Optional[st
     return companion.open_beside(root, env) or None
 
 
-def on_prompt(root: Path, payload: Dict[str, Any]) -> None:
-    """The person sent a prompt: a new turn starts. A notice Claude Code sends as a prompt (a background task done)
+def on_prompt(root: Path, payload: Dict[str, Any]) -> Optional[Dict[str, str]]:
+    """The person sent a prompt: a new turn starts, and Claude is told to plan the work for a team of agents (unless
+    the config says `[agents] orchestrate = false`). A notice Claude Code sends as a prompt (a background task done)
     is not one: the turn goes on."""
     if activity.is_system(payload.get("prompt") or ""):
-        return
+        return None
     mark_turn(root)
     activity.new_turn(root)
     activity.record(root, {"event": activity.PROMPT, "text": _clip(payload.get("prompt"), 300),
-                           "session": payload.get("session_id", "")})
+                           "session": payload.get("session_id", ""), "agent": payload.get("agent_id") or ""})
+    if (config.lenient(root).get("agents") or {}).get("orchestrate", True) is False or payload.get("agent_id"):
+        return None
+    return {"context": agents.ORCHESTRATE}
 
 
-def on_tool(root: Path, payload: Dict[str, Any]) -> Optional[str]:
+def on_tool(root: Path, payload: Dict[str, Any]) -> Optional[Dict[str, str]]:
     """Note the file and keep a brief of its part for the status line. After an edit to code, look at what the turn
     has done to the system so far, and say what this edit added to it (one hook at a time: they can overlap)."""
     tool = payload.get("tool_name", "")
@@ -143,8 +147,9 @@ def on_tool(root: Path, payload: Dict[str, Any]) -> Optional[str]:
     if not path:
         return None
     edit = tool in EDIT_TOOLS
+    agent_id = payload.get("agent_id") or ""
     activity.record(root, {"event": activity.EDIT if edit else activity.READ, "path": path, "tool": tool,
-                           "session": payload.get("session_id", "")})
+                           "session": payload.get("session_id", ""), "agent": agent_id})
     cfg = config.lenient(root)
     part = activity.part_of(path, Code(cfg))
     if part is None:
@@ -160,9 +165,13 @@ def on_tool(root: Path, payload: Dict[str, Any]) -> Optional[str]:
         before = last.get("told") or [s["text"] for s in last.get("story") or []]
         since, turn = compare_worktree(root, ["checkpoint", "turn"])
         notes = design.Reading(turn).notes()
-        record_step(root, path, part, last.get("noted") or [], notes)
+        noted = set(last.get("noted") or [])
+        record_step(root, path, part, noted, notes)
         activity.write_state(root, since.diff, since.base, turn.diff, noted=[n["text"] for n in notes])
-        return step_message(before, learn.story(turn.diff))
+        said = step_message(before, learn.story(turn.diff))
+    team = agents.after_edit(root, agent_id, part, [n for n in notes if n["text"] not in noted], turn.after)
+    message = "; ".join(m for m in (said, f"System diff: {team['warn']}" if team["warn"] else "") if m)
+    return {"message": message, "context": team["context"]}
 
 
 def record_step(root: Path, path: str, part: str, before: Iterable[str], notes: List[Dict[str, Any]]) -> None:
@@ -206,9 +215,19 @@ def run_hook(stdin_text: str, emit: Callable[[str], None] = print) -> int:
         if event == "SessionStart":
             message = on_start(root, payload)
         elif event == "UserPromptSubmit":
-            on_prompt(root, payload)
+            said = on_prompt(root, payload) or {}
+            if said.get("context"):
+                emit(json.dumps({"hookSpecificOutput": {"hookEventName": "UserPromptSubmit",
+                                                        "additionalContext": said["context"]}}))
         elif event == "PostToolUse":
-            message = on_tool(root, payload)
+            said = on_tool(root, payload) or {}
+            message = said.get("message") or None
+            if said.get("context"):   # what other agents published, for this agent to read with its tool result
+                out = {"hookSpecificOutput": {"hookEventName": "PostToolUse", "additionalContext": said["context"]}}
+                if message:
+                    out["systemMessage"] = message
+                emit(json.dumps(out))
+                message = None
         elif event == "Stop":
             message = on_stop(root, payload)
         if message:
@@ -225,7 +244,8 @@ HOOKS = (  # event, matcher, how it runs, what it does
     ("SessionStart", "startup|resume", {"timeout": 10},
      "when a session starts, opens the terminal view beside Claude where the terminal can split (tmux, zellij, "
      "WezTerm, kitty, Windows Terminal)"),
-    ("UserPromptSubmit", None, {"async": True}, "marks where each turn starts (in the background)"),
+    ("UserPromptSubmit", None, {"timeout": 10},
+     "marks where each turn starts, and asks Claude to plan the work for a team of agents"),
     ("PostToolUse", "|".join(READ_TOOLS), {"async": True},
      "notes the files Claude reads, for the terminal view and the status line (in the background)"),
     # Not in the background: only a hook Claude Code waits for can show you a line in the conversation. A timeout

system_diff/agents.py

@@ -0,0 +1,351 @@
+"""Many agents on one system: a PLAN that splits a task by the system's blocks, one agent per area, each with its brief;
+CLAIMS, so agents keep to their own blocks; and a BUS, an async publish/subscribe channel whose topics are the system's
+blocks: an agent subscribes to the blocks its own depend on, every structural change to a block is published on that
+block's topic (by the hooks, as it happens), agents publish their own notes too, and each agent's unread messages
+reach it with its next tool call, without waiting on anyone.
+
+Who is who: Claude Code names each subagent by an id (`agent_id` in its hook events; the main conversation has none,
+"main" here). A plan names agents by area ("billing"); an id is tied to a name when it first edits a block that name
+claimed, or when it claims or publishes under that name.
+
+Kept in .git/system-diff/ (never committed): agents.json (plan, claims, names, subscriptions, read cursors) and
+bus.jsonl (the messages, newest last).
+"""
+from __future__ import annotations
+
+import json
+import re
+import time
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional
+
+from . import activity, design
+from .sources import git_dir
+
+STATE, BUS = "agents.json", "bus.jsonl"
+MAIN = "main"
+SYSTEM = "system-diff"   # the sender of what system-diff itself publishes
+KEEP = 2000        # messages kept on the bus
+MOST_AGENTS = 4    # a plan's agents at most, unless asked for more
+
+
+def _load(root: Path) -> Dict[str, Any]:
+    try:
+        data = json.loads((git_dir(root) / STATE).read_text(encoding="utf-8"))
+        if isinstance(data, dict):
+            return {"plan": data.get("plan") or {}, "claims": data.get("claims") or {},
+                    "agents": data.get("agents") or {}, "ids": data.get("ids") or {},
+                    "warned": data.get("warned") or {}}
+    except (OSError, ValueError):
+        pass
+    return {"plan": {}, "claims": {}, "agents": {}, "ids": {}, "warned": {}}
+
+
+def _save(root: Path, data: Dict[str, Any]) -> None:
+    activity._replace(git_dir(root) / STATE, json.dumps(data, ensure_ascii=False, indent=1) + "\n")
+
+
+def state(root: Path) -> Dict[str, Any]:
+    return _load(root)
+
+
+def _agent(data: Dict[str, Any], name: str) -> Dict[str, Any]:
+    return data["agents"].setdefault(name, {"topics": [], "read": 0, "blocks": [], "brief": ""})
+
+
+def name_of(root: Path, agent_id: str) -> str:
+    """The name an agent goes by: its plan name once tied to one, else "main" or a short form of its id."""
+    if not agent_id or agent_id == MAIN:
+        return MAIN
+    return _load(root)["ids"].get(agent_id) or "agent-" + agent_id[:6]
+
+
+def tie(root: Path, agent_id: str, name: str) -> None:
+    if agent_id and agent_id != MAIN and name:
+        data = _load(root)
+        if data["ids"].get(agent_id) != name:
+            data["ids"][agent_id] = name
+            _save(root, data)
+
+
+# ── claims ────────────────────────────────────────────────────────────────────
+
+def claim(root: Path, agent: str, blocks: Iterable[str]) -> Dict[str, str]:
+    """`agent` takes `blocks`; returns the blocks another agent had, by that agent."""
+    data = _load(root)
+    taken = {}
+    for b in blocks:
+        had = data["claims"].get(b)
+        if had and had != agent:
+            taken[b] = had
+        data["claims"][b] = agent
+        a = _agent(data, agent)
+        if b not in a["blocks"]:
+            a["blocks"].append(b)
+    _save(root, data)
+    return taken
+
+
+def owner(root: Path, block: str) -> Optional[str]:
+    return _load(root)["claims"].get(block)
+
+
+# ── the bus ───────────────────────────────────────────────────────────────────
+
+def publish(root: Path, topic: str, text: str, sender: str = MAIN, why: str = "", kind: str = "note") -> Dict[str, Any]:
+    """A message on a topic (a block's id, "all", or "agent:<name>" for one agent)."""
+    path = git_dir(root) / BUS
+    try:
+        last = int(json.loads(path.read_text(encoding="utf-8").splitlines()[-1])["n"])
+    except (OSError, ValueError, IndexError, KeyError):
+        last = 0
+    msg = {"n": last + 1, "at": round(time.time(), 3), "topic": topic, "from": sender, "kind": kind,
+           "text": text, "why": why}
+    with open(path, "a", encoding="utf-8") as f:
+        f.write(json.dumps(msg, ensure_ascii=False) + "\n")
+    if msg["n"] % 200 == 0:   # trimmed now and then
+        lines = path.read_text(encoding="utf-8").splitlines()[-KEEP:]
+        activity._replace(path, "\n".join(lines) + "\n")
+    return msg
+
+
+def messages(root: Path, after: int = 0) -> List[Dict[str, Any]]:
+    try:
+        lines = (git_dir(root) / BUS).read_text(encoding="utf-8").splitlines()
+    except OSError:
+        return []
+    out = []
+    for line in lines:
+        try:
+            m = json.loads(line)
+        except ValueError:
+            continue
+        if m.get("n", 0) > after:
+            out.append(m)
+    return out
+
+
+def subscribe(root: Path, agent: str, topics: Iterable[str]) -> List[str]:
+    data = _load(root)
+    a = _agent(data, agent)
+    for t in topics:
+        if t and t not in a["topics"]:
+            a["topics"].append(t)
+    _save(root, data)
+    return a["topics"]
+
+
+def inbox(root: Path, agent: str, mark: bool = True) -> List[Dict[str, Any]]:
+    """`agent`'s unread messages: on the topics it subscribes to, "all", and its own; never its own sends."""
+    data = _load(root)
+    a = _agent(data, agent)
+    want = set(a["topics"]) | {"all", f"agent:{agent}"}
+    new = [m for m in messages(root, a["read"]) if m["topic"] in want and m["from"] != agent]
+    if mark:
+        latest = messages(root, a["read"])
+        if latest:
+            a["read"] = latest[-1]["n"]
+            _save(root, data)
+    return new
+
+
+def as_context(msgs: List[Dict[str, Any]], most: int = 8) -> str:
+    """Messages as a few lines an agent reads with its next tool result."""
+    if not msgs:
+        return ""
+    lines = [f"[system-diff bus] {len(msgs)} new message{'' if len(msgs) == 1 else 's'} from other agents:"]
+    for m in msgs[-most:]:
+        why = f" ({m['why']})" if m.get("why") else ""
+        lines.append(f"- {m['from']} on {m['topic']}: {m['text']}{why}")
+    lines.append("Adjust your work if it depends on these; publish what others need to know with the publish tool.")
+    return "\n".join(lines)
+
+
+# ── what the hooks do for each agent ─────────────────────────────────────────
+
+def after_edit(root: Path, agent_id: str, part: Optional[str], notes: List[Dict[str, Any]], bp: dict) -> Dict[str, str]:
+    """After an agent's edit: tie it to a plan name if it edited a claimed block nobody else is tied to, subscribe it
+    to its block and the blocks that block depends on, publish what the edit changed in the structure on the topics
+    of the blocks it changed, and return {"context": unread messages for the agent, "warn": a claim it stepped on}."""
+    data = _load(root)
+    name = data["ids"].get(agent_id) if agent_id and agent_id != MAIN else MAIN
+    claimed = data["claims"].get(part or "")
+    if not name and claimed and claimed not in data["ids"].values():
+        tie(root, agent_id, claimed)
+        name = claimed
+    name = name or ("agent-" + agent_id[:6])
+    if part:
+        deps = sorted(design.depends(bp).get(part, ()))
+        subscribe(root, name, [part] + deps)
+    for n in design.summarize(notes):
+        topic = (n.get("parts") or [part or "all"])[0] or "all"
+        publish(root, topic, n["text"], sender=name, why=n.get("why", ""), kind="change")
+    warn = ""
+    if part and claimed and claimed != name:
+        warn = f"{part} is claimed by agent {claimed}; {name} just edited it"
+        publish(root, f"agent:{claimed}", f"{name} edited your block {part}", sender=name, kind="warning")
+    from . import config
+    wide = spread(root, name, agent_id, bp, config.lenient(root))
+    # spread warnings reach the agent they are about directly; on the bus they are a record for the inbox tool
+    unread = [m for m in inbox(root, name) if not (m.get("from") == SYSTEM and m.get("kind") == "warning")]
+    context = "\n".join(t for t in (as_context(unread), wide) if t)
+    warn = "; ".join(t for t in (warn, wide) if t)
+    return {"context": context, "warn": warn, "name": name}
+
+
+def areas_of(root: Path, bp: dict, cfg: Dict[str, Any]) -> Dict[str, str]:
+    """Each block's area: the agent the saved plan gave it to, when there is a plan; else its container, or the
+    block itself when it is in none."""
+    agents = (_load(root)["plan"] or {}).get("agents") or []
+    if agents:
+        return {b: g["name"] for g in agents for b in g.get("blocks") or []}
+    from .architecture import groups_of
+    group = groups_of(bp, cfg, design.kinds(bp, cfg))
+    return {cid: (group[cid][2:] if group.get(cid, "").startswith("g:") else cid) for cid in bp["components"]}
+
+
+def spread(root: Path, name: str, agent_id: str, bp: dict, cfg: Dict[str, Any]) -> str:
+    """When one agent has edited blocks in two or more areas this turn: a message telling it to plan a team and hand
+    the rest on, once per agent per turn (also published to all); else ""."""
+    from .extract import Code
+    code = Code(cfg)
+    me = "" if agent_id in ("", None, MAIN) else agent_id
+    start, parts = 0.0, []
+    for e in activity.events(root, 400):
+        if e.get("event") == activity.PROMPT and not activity.is_system(e.get("text", "")):
+            start, parts = e["at"], []
+        elif e.get("event") == activity.EDIT and (e.get("agent") or "") == me and e.get("path"):
+            part = activity.part_of(e["path"], code)
+            if part and part not in parts:
+                parts.append(part)
+    area = areas_of(root, bp, cfg)
+    seen: List[str] = []
+    for p in parts:
+        a = area.get(p, p)
+        if a not in seen:
+            seen.append(a)
+    if len(seen) < 2:
+        return ""
+    data = _load(root)
+    turn = str(start)
+    told = data["warned"].get(turn) or []
+    if name in told:
+        return ""
+    data["warned"] = {turn: told + [name]}   # only the latest turn is kept
+    _save(root, data)
+    text = (f"{name} has edited blocks in {len(seen)} areas this turn ({', '.join(seen)}). system-diff runs work "
+            "that spans areas as a team: call plan_agents with what is left, launch its agents in parallel, and "
+            "keep to one area yourself.")
+    publish(root, "all", text, sender=SYSTEM, kind="warning")
+    return text
+
+
+def who_worked(events: Iterable[dict], code) -> Dict[str, Dict[str, Any]]:
+    """Each agent seen in the activity log since the last prompt: the parts it edited and read, when it last acted."""
+    out: Dict[str, Dict[str, Any]] = {}
+    for e in events:
+        if e.get("event") == activity.PROMPT and not activity.is_system(e.get("text", "")):
+            out = {}
+            continue
+        if e.get("event") not in (activity.EDIT, activity.READ) or not e.get("path"):
+            continue
+        a = out.setdefault(e.get("agent") or MAIN, {"edits": [], "reads": [], "at": 0.0})
+        part = activity.part_of(e["path"], code)
+        if part:
+            key = "edits" if e["event"] == activity.EDIT else "reads"
+            if part not in a[key]:
+                a[key].append(part)
+        a["at"] = max(a["at"], e["at"])
+    return out
+
+
+# ── the plan ──────────────────────────────────────────────────────────────────
+
+WORD = re.compile(r"[a-z0-9]+")
+
+
+def _areas(c) -> List[Dict[str, Any]]:
+    """Where work can be split: each container (its parts together), else each part on its own."""
+    from .architecture import groups_of
+    bp, cfg = c.after, c.cfg
+    kind = design.kinds(bp, cfg)
+    group = groups_of(bp, cfg, kind)
+    areas: Dict[str, Dict[str, Any]] = {}
+    for cid, comp in bp["components"].items():
+        if comp.get("quiet"):
+            continue
+        key = group.get(cid, cid)
+        a = areas.setdefault(key, {"id": key, "title": key[2:] if key.startswith("g:") else comp["label"],
+                                   "blocks": []})
+        a["blocks"].append(cid)
+    return list(areas.values())
+
+
+def plan(root: Path, c, task: str, most: int = MOST_AGENTS, focus: Iterable[str] = ()) -> Dict[str, Any]:
+    """Split `task` across agents by the system's blocks: the areas (containers, else parts) the task names or that
+    `focus` gives, one agent each (at most `most`, the rest joining the closest), each with the blocks it claims, the
+    blocks it depends on (its subscriptions) and a brief; and how to run them. Saved, and the claims made."""
+    bp = c.after
+    words = set(WORD.findall(task.lower()))
+    deps = design.depends(bp)
+    scored = []
+    for a in _areas(c):
+        text = " ".join([a["title"]] + [bp["components"][b]["label"] + " " + b for b in a["blocks"]]).lower()
+        hit = len(words & set(WORD.findall(text))) + 3 * len(set(focus) & set(a["blocks"]))
+        if hit:
+            scored.append((hit, a))
+    if not scored:   # nothing named: the areas the task's likely to touch are the ones most depended on
+        into = design.fan_in(deps)
+        scored = sorted(((sum(into.get(b, 0) for b in a["blocks"]) + 1, a) for a in _areas(c)), key=lambda s: -s[0])
+    areas = [a for _s, a in sorted(scored, key=lambda s: (-s[0], s[1]["id"]))]
+    picked, rest = areas[:most], areas[most:]
+    for a in rest:   # joins the picked area it is most connected to
+        best = max(picked, key=lambda p: sum(1 for b in a["blocks"] for d in deps.get(b, ()) if d in p["blocks"])
+                   + sum(1 for b in p["blocks"] for d in deps.get(b, ()) if d in a["blocks"]))
+        best["blocks"] += a["blocks"]
+    agents = []
+    owned = {b: a["id"] for a in picked for b in a["blocks"]}
+    for a in picked:
+        name = re.sub(r"[^a-z0-9]+", "-", a["title"].lower()).strip("-") or "agent"
+        needs = sorted({d for b in a["blocks"] for d in deps.get(b, ()) if d not in a["blocks"]})
+        needed_by = sorted({b2 for b2, ds in deps.items() for d in ds if d in a["blocks"] and b2 not in a["blocks"]})
+        talks_to = sorted({re.sub(r"[^a-z0-9]+", "-", next(p["title"] for p in picked if p["id"] == owned[x]).lower())
+                           for x in needs + needed_by if x in owned and owned[x] != a["id"]})
+        label = lambda ids: design.and_list([bp["components"][i]["label"] for i in ids if i in bp["components"]], 6)
+        brief = (f"You are the {a['title']} agent in a team working on: {task}\n"
+                 f"Work only in these blocks (claimed for you): {label(a['blocks'])}. "
+                 f"First call the system-diff `claim` tool with agent \"{name}\" and these blocks.\n"
+                 + (f"Your blocks use {label(needs)}: you are subscribed to them, so changes other agents make there "
+                    "reach you with your next tool result.\n" if needs else "")
+                 + (f"{label(needed_by)} use your blocks: keep their interfaces stable, and when you must change one, "
+                    f"say so with the `publish` tool (topic: the block's id) before you do.\n" if needed_by else "")
+                 + (f"Coordinate with: {', '.join(talks_to)}.\n" if talks_to else "")
+                 + "Finish with a short summary of what you changed in the system's structure.")
+        agents.append({"name": name, "area": a["title"], "blocks": a["blocks"], "subscribes": needs,
+                       "talks_to": talks_to, "brief": brief})
+    data = _load(root)
+    data["plan"] = {"task": task, "at": round(time.time(), 3), "agents": [{k: v for k, v in g.items() if k != "brief"}
+                                                                          for g in agents]}
+    for g in agents:
+        a = _agent(data, g["name"])
+        a["brief"] = g["brief"]
+        a["blocks"] = list(g["blocks"])
+        a["topics"] = sorted(set(a["topics"]) | set(g["subscribes"]) | {f"agent:{g['name']}"})
+        for b in g["blocks"]:
+            data["claims"][b] = g["name"]
+    _save(root, data)
+    how = ("Launch these agents now, in parallel, each as its own subagent with its brief as the prompt (one message "
+           "with several Task/Agent tool calls). Do not do their work yourself. When they finish, read the system-diff "
+           "`inbox` tool as \"main\" and integrate: resolve what they published, then check the whole with "
+           "`system_diff`." if len(agents) > 1 else
+           "One area: do it yourself; no team needed.")
+    publish(root, "all", f"Plan: {len(agents)} agent{'' if len(agents) == 1 else 's'} for: {task}", sender=MAIN,
+            kind="plan")
+    return {"task": task, "agents": agents, "how": how}
+
+
+ORCHESTRATE = ("system-diff: this repository works with a team of agents. Before you start on a task that touches "
+               "more than one part of the system, call the system-diff `plan_agents` tool with the task; when it "
+               "returns two or more agents, launch them in parallel as subagents with their briefs and coordinate "
+               "through its bus (`inbox`, `publish`) instead of doing every part yourself. Small, single-part tasks "
+               "need no team.")

system_diff/canvas.py

@@ -138,8 +138,12 @@ def title_style(n: dict) -> str:
     return f"title bold {st}" if st != "same" else "title"
 
 
+ZOOMS = {0: (20, 32, 2, 6, 4), 1: (12, 22, 0, 5, 3), 2: (8, 16, 0, 5, 3)}  # min box, max box, rows, channel, gap
+                                                                         # by zoom: full, compact, tiny
+
+
 def layered(nodes: List[dict], edges: List[dict], columns: List[Sequence[str]], *, width: int = 100,
-            centre: bool = False, most_lines: int = 2) -> Grid:
+            centre: bool = False, most_lines: int = 2, zoom: int = 0) -> Grid:
     """A system diagram: `nodes` (id, col, title, sub, status, type: actor|component|group|store|host; `agent` where
     the agent works, `focus` for the box zoomed in on, `items` for the components a container holds, `lines` for
     rows inside a box) in `columns` order, joined by `edges` (from, to, kind, status, label; `from_item`/`to_item`:
@@ -150,6 +154,12 @@ def layered(nodes: List[dict], edges: List[dict], columns: List[Sequence[str]],
     present = [k for k, _h in columns if any(n["col"] == k for n in nodes)]
     if not present:
         return g
+    least, most_w, rows_in, chan_min, chan_pad = ZOOMS.get(zoom, ZOOMS[0])
+    most_lines = min(most_lines, rows_in)
+    if zoom:   # compact: no labels on flows (a picked box's detail names them), tiny: no subtitles either
+        edges = [{**e, "label": ""} for e in edges]
+        if zoom >= 2:
+            nodes = [{**n, "sub": ""} for n in nodes]
     heading = {k: h for k, h in columns}
     ci = {k: i for i, k in enumerate(present)}
     col_nodes = [[n for n in nodes if n["col"] == k] for k in present]
@@ -181,13 +191,13 @@ def layered(nodes: List[dict], edges: List[dict], columns: List[Sequence[str]],
     item_row = {it["id"]: (n["id"], 3 + j) for n in nodes for j, it in enumerate(n.get("items") or [])}
 
     # widths: as wide as the longest row wants, narrowed together when the whole is wider than the pane
-    want = [min(32, max([len(t) + 4 for n in col for t, _s, _b in contents[n["id"]][:1]]
-                        + [len(t) + 4 for n in col for t, _s, _b in contents[n["id"]][2:]]
-                        + [len(heading[present[i]]) + 1, 14]))
+    want = [min(most_w, max([len(t) + 4 for n in col for t, _s, _b in contents[n["id"]][:1]]
+                            + [len(t) + 4 for n in col for t, _s, _b in contents[n["id"]][2:]]
+                            + [min(len(heading[present[i]]) + 1, most_w), least]))
             for i, col in enumerate(col_nodes)]
     label_w = max([len(e.get("label") or "") for e in edges] + [0])
-    gaps = (8 + label_w) * len(present)
-    while sum(want) + gaps > width and max(want) > 20:
+    gaps = (chan_min + 2 + label_w) * len(present)
+    while sum(want) + gaps > width and max(want) > least:
         biggest = max(range(len(want)), key=lambda i: want[i])
         want[biggest] -= 1
     heights = {n["id"]: 2 + len(contents[n["id"]]) for n in nodes}
@@ -320,7 +330,7 @@ def layered(nodes: List[dict], edges: List[dict], columns: List[Sequence[str]],
         if e.get("label") and cs != ct:
             label_in[hops[-1][0]] = max(label_in[hops[-1][0]], len(e["label"]) + 2)
     widths = want
-    chan = [max(6, len(lanes[k]) + 4 + label_in[k]) for k in range(len(present))]
+    chan = [max(chan_min, len(lanes[k]) + chan_pad + label_in[k]) for k in range(len(present))]
     if not lanes[len(present) - 1]:
         chan[-1] = 0
     xs, x = [], 0

system_diff/cli.py

@@ -193,8 +193,9 @@ def parser() -> argparse.ArgumentParser:
                                 "the end of a turn one line on what it changed in the system")
     pn = sub.add_parser("panel", help="what a pane beside the agent shows, as JSON (for the Claude Code mod)")
     pn.add_argument("--width", type=int, default=80)
-    pn.add_argument("--view", default="now", choices=["now", "map", "changes", "topics"])
+    pn.add_argument("--view", default="now", choices=["now", "map", "changes", "topics", "agents"])
     pn.add_argument("--part", default="", help="the part to zoom in on (default: the one the agent works on)")
+    pn.add_argument("--zoom", type=int, default=-1, help="diagrams 0 full, 1 compact, 2 tiny; -1 by the width")
     pn.add_argument("--protocol", type=int, default=1, help="2: a page of runs and pickable blocks (the mod's painter)")
     pf = sub.add_parser("profile", help="what you want explained: technologies marked new to you")
     pf.add_argument("--learn", metavar="TECH", help="mark a technology new to you, or unmark it")
@@ -254,7 +255,7 @@ def main(argv: Optional[List[str]] = None) -> int:
         return agent.run_hook(sys.stdin.read() if not sys.stdin.isatty() else "")
     if args.cmd == "panel":
         from . import panel
-        return panel.main(root, args.width, args.view, args.part, args.protocol)
+        return panel.main(root, args.width, args.view, args.part, args.protocol, args.zoom)
     if args.cmd == "profile":
         from . import profile
         if args.learn:

system_diff/mcp_server.py

@@ -16,7 +16,7 @@ try:  # the MCP SDK's 2.x name; 1.x called it FastMCP, with the same constructor
 except ImportError:  # pragma: no cover - mcp 1.x
     from mcp.server.fastmcp import FastMCP as Server
 
-from . import activity, config, graph, learn, pictures, textmap
+from . import activity, agents, config, graph, learn, pictures, textmap
 from . import compare as cmp
 from .extract import Code as CodeOf  # the spec's own Code, below, is a line of a picture
 from .extract import extract
@@ -29,7 +29,9 @@ INSTRUCTIONS = (
     "this turn changed. Use explain when the person asks what a part is or does, or about a technology in it: it "
     "gives the facts to teach from and a diagram to paste in a code block. Use system_map for the whole system, and "
     "draw for a picture of something else (a process, a sequence). Call checkpoint only when the person says they "
-    "have seen and understood the current state."
+    "have seen and understood the current state. For work that touches more than one part, plan a team with "
+    "plan_agents and launch its agents in parallel as subagents; agents claim their blocks with claim, tell others "
+    "about changes with publish (topics are block ids), and read what others published with inbox."
 )
 WIDTH = 100  # the columns a diagram is drawn for
 
@@ -233,6 +235,46 @@ def build() -> Server:
         sha = cmp.checkpoint(repo_root(), ref or None)
         return {"checkpoint": sha[:9], "of": ref or "the working tree"}
 
+    @server.tool()
+    def plan_agents(task: str, most: int = 4, focus: List[str] = []) -> Dict[str, Any]:  # noqa: B006
+        """Split a task across a team of agents by the system's blocks: one agent per area the task touches (a
+        container, else a part), at most `most`, each with the blocks it owns, the blocks it depends on (it is
+        subscribed to them on the bus) and a brief to launch it with. `focus`: block ids to include. Claims the
+        blocks. Then launch the agents in parallel as subagents, each with its brief as its prompt."""
+        root = repo_root()
+        c = cmp.compare(root, "checkpoint", ".")
+        return agents.plan(root, c, task, most, focus)
+
+    @server.tool()
+    def claim(agent: str, blocks: List[str]) -> Dict[str, Any]:
+        """Take blocks (part ids) for `agent` (its name in the plan), so other agents keep out of them. Returns the
+        blocks another agent had."""
+        return {"agent": agent, "taken_from_others": agents.claim(repo_root(), agent, blocks)}
+
+    @server.tool()
+    def publish(agent: str, topic: str, text: str) -> Dict[str, Any]:
+        """Tell the other agents something, async: on a block's topic (its id: those working on what depends on it
+        read it with their next tool result), "all", or "agent:<name>" for one agent. Changes to a block's structure
+        are published by system-diff itself; publish plans, contracts and questions."""
+        return agents.publish(repo_root(), topic, text, sender=agent)
+
+    @server.tool()
+    def subscribe(agent: str, topics: List[str]) -> Dict[str, Any]:
+        """Follow more topics (block ids). An agent already follows its own blocks and the blocks they depend on."""
+        return {"agent": agent, "topics": agents.subscribe(repo_root(), agent, topics)}
+
+    @server.tool()
+    def inbox(agent: str = "main") -> Dict[str, Any]:
+        """`agent`'s unread messages from the other agents (and marks them read)."""
+        return {"agent": agent, "messages": agents.inbox(repo_root(), agent)}
+
+    @server.tool()
+    def team() -> Dict[str, Any]:
+        """The plan, who claims which block, and the latest messages on the bus."""
+        root = repo_root()
+        st = agents.state(root)
+        return {"plan": st["plan"], "claims": st["claims"], "messages": agents.messages(root)[-20:]}
+
     return server
 
 

system_diff/pane.py

@@ -16,7 +16,7 @@ from collections import Counter, defaultdict
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from . import activity, architecture, canvas, config, design, graph, inside, profile
+from . import activity, agents, architecture, canvas, config, design, graph, inside, profile
 from .compare import compare, turn_sha
 from .extract import Code, first_party, outside_imports
 from .learn import STDLIB, BASIC
@@ -35,7 +35,7 @@ def _name(nid: str, *bps: dict) -> str:
 def _diagram(page: canvas.Page, c, model: Dict[str, Any], width: int, centre: bool = False) -> canvas.Grid:
     """The diagram on the page, every box a block: Enter zooms in on it; its detail says what it uses and what uses
     it, all of it (the diagram draws each box's main flows)."""
-    g = canvas.layered(model["nodes"], model["edges"], model["columns"], width=width, centre=centre)
+    g = canvas.layered(model["nodes"], model["edges"], model["columns"], width=width, centre=centre, zoom=ZOOM)
     conns = graph.connections(c.after)
     names = {n["id"]: n["title"] for n in model["nodes"]}
     names.update({i["id"]: i["title"] for n in model["nodes"] for i in n.get("items") or []})
@@ -229,7 +229,7 @@ def view_now(root: Path, width: int, part: str) -> Dict[str, Any]:
     page = canvas.Page(width)
     _status(page, now, cfg)
 
-    urgent = [n for n in notes if n["weight"] >= design.ATTENTION]
+    urgent = [n for n in notes if n["weight"] >= design.ATTENTION] + collisions(root, events, code, cfg)
     if urgent:
         page.heading("▲ Needs your attention", "worth a look before Claude goes on")
         page.rows[-1][0][1] = "attention"
@@ -253,6 +253,7 @@ def view_now(root: Path, width: int, part: str) -> Dict[str, Any]:
     if model is None:
         model = architecture.system(c, marks, agent)
         page.heading("System", "● Claude · + new · ~ changed · − gone · click, then ← ↑ ↓ → and ↵")
+    badges(model, root, events, code)
     g = _diagram(page, c, model, width, centre=bool(part))
     ids = {b["id"] for b in g.blocks}
     page.pick = next((b for b in ("b:" + (part or ""), "b:" + (agent or "")) if b in ids), "")
@@ -373,7 +374,123 @@ def view_topics(root: Path, width: int) -> Dict[str, Any]:
     return page.json(view="topics", part="")
 
 
-def show(root: Path, width: int = 80, view: str = "now", part: Optional[str] = None) -> Dict[str, Any]:
+# ── a team of agents ──────────────────────────────────────────────────────────
+
+def team(root: Path, events: List[dict], code: Code) -> Dict[str, Dict[str, Any]]:
+    """Every agent: its plan entry (area, blocks, brief), the parts it edited and read this turn, when it last acted,
+    by the name it goes by."""
+    st = agents.state(root)
+    out: Dict[str, Dict[str, Any]] = {}
+    for g in (st["plan"].get("agents") or []):
+        out[g["name"]] = {"area": g.get("area", ""), "blocks": g.get("blocks", []), "edits": [], "reads": [], "at": 0.0}
+    for aid, seen in agents.who_worked(events, code).items():
+        name = st["ids"].get(aid) or (agents.MAIN if aid == agents.MAIN else "agent-" + aid[:6])
+        a = out.setdefault(name, {"area": "", "blocks": [], "edits": [], "reads": [], "at": 0.0})
+        a["edits"] = sorted(set(a["edits"]) | set(seen["edits"]))
+        a["reads"] = sorted(set(a["reads"]) | set(seen["reads"]))
+        a["at"] = max(a["at"], seen["at"])
+    return out
+
+
+def badges(model: Dict[str, Any], root: Path, events: List[dict], code: Code) -> None:
+    """Who works where, on the diagram: each block's agents (those editing it, else those it is claimed for) after
+    its title, when more than one agent is about."""
+    who = team(root, events, code)
+    if len(who) < 2:
+        return
+    on: Dict[str, List[str]] = defaultdict(list)
+    for name, a in who.items():
+        for part in (a["edits"] or a["blocks"]):
+            if name not in on[part]:
+                on[part].append(name)
+    for n in model["nodes"]:
+        for box in [n] + list(n.get("items") or []):
+            if on.get(box["id"]):
+                box["title"] += "  " + " ".join(f"@{t}" for t in on[box["id"]][:2])
+
+
+def collisions(root: Path, events: List[dict], code: Code, cfg: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """Agents in each other's way this turn: two editing one block, or one editing a block claimed for another."""
+    who = team(root, events, code)
+    claims = agents.state(root)["claims"]
+    editors: Dict[str, List[str]] = defaultdict(list)
+    for name, a in who.items():
+        for part in a["edits"]:
+            editors[part].append(name)
+    out = []
+    for part, names in sorted(editors.items()):
+        P = activity.label(cfg, part)
+        if len(names) > 1:
+            out.append({"sign": "▲", "status": "warn", "weight": 9, "text": f"{design.and_list(names)} all edit {P}",
+                        "why": "two agents changing one block can undo each other's work", "ask":
+                        f"Should {P} be left to {claims.get(part) or names[0]}, the others publishing what they need?"})
+        elif claims.get(part) and claims[part] not in names and names != [agents.MAIN]:
+            out.append({"sign": "▲", "status": "warn", "weight": 8, "text": f"{names[0]} edits {P}, claimed for "
+                        f"{claims[part]}", "why": "outside its own blocks", "ask": ""})
+    return out
+
+
+def view_agents(root: Path, width: int) -> Dict[str, Any]:
+    cfg = config.lenient(root)
+    code = Code(cfg)
+    events = activity.events(root, 400)
+    c = compare(root, "turn" if turn_sha(root) else "checkpoint", ".")
+    st = agents.state(root)
+    who = team(root, events, code)
+    page = canvas.Page(width)
+    task = (st["plan"] or {}).get("task", "")
+    page.heading("The team", f"plan: {canvas.cut(task, width - 22)}" if task else
+                 "no plan yet: Claude makes one with plan_agents")
+    clash = collisions(root, events, code, cfg)
+    if clash:
+        _notes(page, clash, 4, ask=True)
+    for name, a in sorted(who.items(), key=lambda kv: (kv[0] != agents.MAIN, -kv[1]["at"], kv[0])):
+        live = a["at"] and time.time() - a["at"] < 120
+        page.add(["● " if live else "○ ", "accent" if live else "muted"], [name, "bold"],
+                 [f"  {a['area']}" if a["area"] else "", "muted"],
+                 [f"  {time.strftime('%H:%M', time.localtime(a['at']))}" if a["at"] else "  not started", "muted"])
+        mine = [activity.label(cfg, b) for b in a["blocks"]]
+        if mine:
+            page.para("owns " + design.and_list(mine, 5), "muted", indent=4)
+        if a["edits"]:
+            page.para("edited " + design.and_list([activity.label(cfg, b) for b in a["edits"]], 5), "", indent=4)
+        unread = len(agents.inbox(root, name, mark=False))
+        if unread:
+            page.add([f"    {unread} unread on the bus", "attention"])
+    if not who:
+        page.add(["   no agent has touched the code yet", "muted"])
+    page.heading("Who works where", "@name after a block: the agents on it")
+    model = architecture.system(c, None, activity.now(events, code)["part"])
+    badges(model, root, events, code)
+    _diagram(page, c, model, width)
+    page.heading("The bus", "what agents told each other, newest first")
+    msgs = agents.messages(root)[-10:][::-1]
+    for m in msgs:
+        style = {"change": "changed", "warning": "attention", "plan": "accent"}.get(m.get("kind", ""), "")
+        page.add([time.strftime("%H:%M ", time.localtime(m["at"])), "muted"], [m["from"], "bold"],
+                 [f" → {m['topic']}: ", "muted"], [canvas.cut(m["text"], width - 20 - len(m["topic"])), style])
+        if m.get("why"):
+            page.add(["        " + canvas.cut(m["why"], width - 9), "muted"])
+    if not msgs:
+        page.add(["   nothing yet: changes to a block are published here as agents make them", "muted"])
+    return page.json(view="agents", part="")
+
+
+ZOOM = 0   # how compact the diagrams are drawn: 0 full, 1 compact, 2 tiny (show sets it)
+
+
+def show(root: Path, width: int = 80, view: str = "now", part: Optional[str] = None, zoom: int = -1) -> Dict[str, Any]:
+    """The page for a view. `zoom` -1: compact below 110 columns, full above."""
+    global ZOOM
+    ZOOM = (1 if width < 110 else 0) if zoom < 0 else max(0, min(2, zoom))
+    out = _show(root, width, view, part)
+    out["zoom"] = ZOOM
+    return out
+
+
+def _show(root: Path, width: int = 80, view: str = "now", part: Optional[str] = None) -> Dict[str, Any]:
+    if view == "agents":
+        return view_agents(root, width)
     if view == "map":
         return view_map(root, width)
     if view == "changes":

system_diff/panel.py

@@ -232,10 +232,11 @@ def rows(root: Path, width: int = 80) -> List[textmap.Line]:
     return got["head"] + got["rows"]
 
 
-def main(root: Path, width: int, view: str = "now", part: Optional[str] = None, protocol: int = 1) -> int:
+def main(root: Path, width: int, view: str = "now", part: Optional[str] = None, protocol: int = 1,
+         zoom: int = -1) -> int:
     if protocol >= 2:
         from . import pane
-        print(json.dumps(pane.show(root, width, view, part or None), ensure_ascii=False))
+        print(json.dumps(pane.show(root, width, view, part or None, zoom), ensure_ascii=False))
         return 0
     got = show(root, width, view, part or None)
     for key in ("head", "rows"):

{system_diff-0.3.4.dist-info → system_diff-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: system-diff
-Version: 0.3.4
+Version: 0.4.2
 Summary: Draws your system from its code (parts, entry points, data, outside systems) and what each change adds, changes or removes. No dependencies; SVG pictures for PRs and READMEs.
 Project-URL: Homepage, https://github.com/simplifiedmachine/system-diff
 Project-URL: Documentation, https://github.com/simplifiedmachine/system-diff/wiki
@@ -92,6 +92,8 @@ Claude is changing in it. `/system-diff close` (or "× close" in its tab row) hi
     - **Zoom:** Enter (or a second click) zooms in on a container's components, with the lines between them. `b` goes
       back, `f` follows Claude again.
     - **Scroll:** `[` `]` scroll a wide diagram across; shift ↑ ↓, Page Up/Down or the wheel scroll a tall one.
+    - **Zoom:** ⊖ and ⊕ in the tab row (or `-` and `=`) draw the diagrams compact (narrower boxes, no flow labels) or
+      tiny (titles only), to fit more of the system in a narrow pane; below 110 columns it is compact by itself.
   - **This turn**: each change to the design, and what it trades off.
   - **Learn**: how the part Claude works on is designed.
     - The principle its place calls for: an edge of the system, an adapter, a shared foundation, a coordinator.
@@ -100,6 +102,9 @@ Claude is changing in it. `/system-diff close` (or "× close" in its tab row) hi
   - **What just happened**: the system diff, step by step. Each change an edit made is said in plain words, with why
     it matters and the file it came from. Edits that changed no structure are told once.
 - **Map**: the system diagram since your checkpoint, every box to pick and zoom into.
+- **Agents**: the team at work. Each agent's area, the blocks it owns and edited, and unread messages; the system
+  diagram with `@agent` after each block it works on; the bus, newest first; and a warning when two agents edit one
+  block, or one edits a block claimed for another.
 - **Changes**: every change since your checkpoint, and this turn, read for design. Once you have understood it, tell
   Claude "mark it as seen" (or run `system-diff checkpoint`): from then on you see only what is new to you.
 - **Topics**: the stack, technology by technology. Pick one and the parts that use it light up in the diagram; space
@@ -116,6 +121,27 @@ One meaning per colour, so your eye goes where it should:
 
 `n` `m` `c` `t` switch views.
 
+### A team of agents, by the system's blocks
+
+Claude does most work alone unless asked otherwise, so system-diff asks it to plan a team:
+
+- **Planning:** at each prompt, the hook tells Claude to call `plan_agents` with the task. The plan splits the task by
+  the system's blocks, one agent per area it touches (a container, else a part). Each agent gets the blocks it owns
+  (claimed for it), the blocks it depends on, and a brief to launch it with. Claude then launches the agents in
+  parallel as subagents. Turn this off with `[agents] orchestrate = false` in `system-diff.toml`.
+- **The bus:** an async publish/subscribe channel whose topics are the blocks. Each agent follows the blocks its own
+  depend on. Every change an agent makes to a block's structure is published on that block's topic as it happens
+  ("API no longer answers DELETE /orders/{id}"), with why it matters. Agents publish their own notes with `publish`
+  (to a block, to "all", or to "agent:<name>"). Each agent's unread messages reach it with its next tool result:
+  nobody waits on anybody.
+- **Claims:** `claim` gives an agent its blocks. An edit to someone else's block is published to its owner and shown
+  under Needs your attention.
+- **One agent, one area:** when an agent (the main conversation included) edits blocks in two or more areas in one
+  turn, the edit hook tells it, once that turn, to plan a team with `plan_agents` and hand the rest to agents.
+
+The MCP tools: `plan_agents`, `claim`, `publish`, `subscribe`, `inbox`, `team`. It all stays in `.git/system-diff/`
+(`agents.json`, `bus.jsonl`), never pushed.
+
 ### In the conversation
 
 - **After an edit that changes the system's structure**, one line under it: "System diff: API now answers GET

{system_diff-0.3.4.dist-info → system_diff-0.4.2.dist-info}/RECORD

@@ -1,10 +1,11 @@
-system_diff/__init__.py,sha256=LwrTgDCI80cQPYW3XYtWCV7ufUT5tiIrtOFBuCzutFU,289
+system_diff/__init__.py,sha256=fKOVXpF3wt-lOcTcNVQIPxe_htHnXkVHWRPHX1wALbQ,289
 system_diff/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
 system_diff/activity.py,sha256=lq5_U-Ulz-mrMALSU8bGB0O4EQHBudSjL8dGALZXxaE,11851
-system_diff/agent.py,sha256=j-A5BWv4u9rSf2KHq7EGI7J2D-b4GWUygNflh0hu0no,21931
+system_diff/agent.py,sha256=3GFqgPLs4-MUgtg0Fob57QA-QN-MJgInv2K7Y6AZ-EE,23382
+system_diff/agents.py,sha256=PiaXDL_t-bY0nQLSu9n-uh2asdQlwK3eGhPOTSn2UWg,17546
 system_diff/architecture.py,sha256=P3Xln9LmdBziQim12KYQKsxLJKesZAHR_F73U-BqwCs,18165
-system_diff/canvas.py,sha256=Gg1LlhaRY0pWmAPAdJ8ooKIi0BJGpYbOULStuDglqnA,25052
-system_diff/cli.py,sha256=oD1YM9RoRX8wUH4AxrjFwtr3MVD8ukIWTUzoDRX2Kfg,16345
+system_diff/canvas.py,sha256=P3TvtSv1p3WEp-SbLfQSff1ttR0x7M-Tiy_Ow_Z4w5M,25695
+system_diff/cli.py,sha256=az2C90_uHcPkWUO_6-s8M73jgwfWSyeWD8BQsOLD9Ys,16478
 system_diff/companion.py,sha256=qmBlfLp0RMS_G0EfqiMBdUmfcvdFAxPk3a1ETTT0SbY,7615
 system_diff/compare.py,sha256=tX6-_xhrM5USlgnaMkMC4fVT4FKoyrjFDRx3r59Slqk,8355
 system_diff/config.py,sha256=zD4XSuUO0xJdxr4IZPeZE1faRpl5YKdHIrjJp3yCGi4,7491
@@ -14,10 +15,10 @@ system_diff/extract.py,sha256=aOeuJpE6POCq3U2LnbcO76M1aSU68qKL_OVH2S7Z65I,55950
 system_diff/graph.py,sha256=PGpIqPLJ6rlG2c6qENw_tKp9gFqnt1X_PC6du_Sl-Ds,18324
 system_diff/inside.py,sha256=thCeHc3mK6GDHFzTBB7_7eLH9CmivuPdLfETS7_A9Z4,11057
 system_diff/learn.py,sha256=0ogIXepNUqXOBFNO_uDwrkhVfMpVPemndPY9n7cBbcw,25088
-system_diff/mcp_server.py,sha256=XQnJuuFvnoiK-pioC7IWZv5kc2vkZlKpaLO8WPDLXYg,11638
+system_diff/mcp_server.py,sha256=uKnEifapKirqTI-XaZNgrfk9E3kA2vmSsrh09H_ydOs,14253
 system_diff/narrate.py,sha256=lnRW9u03AjGVlWL7Zo-Rt2MsTpz569qfSaFu_8X3c8I,8048
-system_diff/pane.py,sha256=zjLhgLf3s1FbKjUhP4jTnLsStEdPpPcRZQLJmbHyTN8,21007
-system_diff/panel.py,sha256=kvIgxdVuaa_wFvV-QtnLYnUkNK7MbF-xRGjlTq_aVrM,11991
+system_diff/pane.py,sha256=iToIErlLbN6QZscPsGVPJJ4z362hJQ50SKtMwUmghdU,27240
+system_diff/panel.py,sha256=GOM0qd6kJ2j5QsKIZDvXCxQmqB7Wb5KLKknttcZjjnI,12022
 system_diff/pictures.py,sha256=G4a8DmvkOttuW962vcGm6CnsbeOTIN_WLrl6ZK0lQGQ,28479
 system_diff/png.py,sha256=HCxc23roQNxHdcsULmMQnvpqLA1Ejkkc1k9lR_Swa14,5775
 system_diff/profile.py,sha256=zW05E_IDpyWreAxdZpA37ZH6QYIHuEedcrgxD2yCavs,1361
@@ -28,8 +29,8 @@ system_diff/textmap.py,sha256=tVUywzuwxcGscLbUy-2etTRq-966kIFuxUDeF1e-lgE,15008
 system_diff/topics.py,sha256=2vbPccf5-jENBLb-P45KZsmaouODglZODYkabwzUXqM,21847
 system_diff/tui.py,sha256=H5jdM3suzgMUBnq2oi5dSOvul2mZTY0bjP3i5iVkgAc,17756
 system_diff/watch.py,sha256=ec3u_YBvfaSVsCXdqd_nDKAKWZzJvKLJm37VMpq6SFo,17066
-system_diff-0.3.4.dist-info/METADATA,sha256=hn-K-1QROUWBZLOp4tsRKLtm_VsDTOb4YUEjAqxnOhE,11232
-system_diff-0.3.4.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
-system_diff-0.3.4.dist-info/entry_points.txt,sha256=8fw6tkuFfZI2L7ScWUXVxj28LK9p6UiImnnB8E1om1E,84
-system_diff-0.3.4.dist-info/licenses/LICENSE,sha256=QHQ-0t-7_4_K7j92CTlQScHiJiDZ91DcpV6WIOIFYQE,1074
-system_diff-0.3.4.dist-info/RECORD,,
+system_diff-0.4.2.dist-info/METADATA,sha256=XNsvSaLEGZ93rVehHu17Xc6-Hsq50pMFHJPXDRkKtNE,13352
+system_diff-0.4.2.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+system_diff-0.4.2.dist-info/entry_points.txt,sha256=8fw6tkuFfZI2L7ScWUXVxj28LK9p6UiImnnB8E1om1E,84
+system_diff-0.4.2.dist-info/licenses/LICENSE,sha256=QHQ-0t-7_4_K7j92CTlQScHiJiDZ91DcpV6WIOIFYQE,1074
+system_diff-0.4.2.dist-info/RECORD,,