system-diff 0.4.0__tar.gz → 0.4.2__tar.gz

{system_diff-0.4.0 → system_diff-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: system-diff
-Version: 0.4.0
+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.
@@ -134,6 +136,8 @@ Claude does most work alone unless asked otherwise, so system-diff asks it to pl
   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.

{system_diff-0.4.0 → system_diff-0.4.2}/README.md

@@ -60,6 +60,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.
@@ -102,6 +104,8 @@ Claude does most work alone unless asked otherwise, so system-diff asks it to pl
   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.

{system_diff-0.4.0 → system_diff-0.4.2}/mods/system-diff/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "system-diff",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "A pane beside the chat: what Claude is working on in your system, zoomed in, what just happened and why it matters, and a topic to learn (system-diff)",
   "types": "./types/index.d.ts",
   "author": {

{system_diff-0.4.0 → system_diff-0.4.2}/mods/system-diff/hooks/page.tsx

@@ -12,7 +12,7 @@ import type { Page, PageBlock, Row, Run } from '../types'
 // the rest keeps its colours: yellow what changed, green what is new, red what went, gray the background.
 
 type Props = { page: Page; canGoBack: boolean }
-type State = { sel: string; sx: number; mine: boolean; ticking?: boolean }
+type State = { sel: string; sx: number; mine: boolean; ticking?: boolean; free?: boolean } // free: scrolled by hand
 
 const COLORS: Record<string, string> = {
   accent: 'blue', focus: 'blue', near: 'blue', data: 'blue',
@@ -88,7 +88,7 @@ const PageView: ClientModule<JsonValue, State> = (raw, surface) => {
   const state = surface.state
   const sel = state?.mine && byId.has(state.sel) ? state.sel : byId.has(page.pick) ? page.pick : (page.blocks[0]?.id ?? '')
   const picked = byId.get(sel)
-  const sx = across(page, cols, state?.mine ? state.sx : 0, picked)
+  const sx = across(page, cols, state?.mine ? state.sx : 0, state?.free ? undefined : picked)
 
   // The pane was laid out for another width (the split moved): ask for this one once it holds, not for every
   // width a drag passes on its way.
@@ -104,7 +104,8 @@ const PageView: ClientModule<JsonValue, State> = (raw, surface) => {
         surface.post({ width: askedWidth })
       }
     })
-    surface.setState({ sel: state?.sel ?? '', sx: state?.sx ?? 0, mine: state?.mine ?? false, ticking: true })
+    surface.setState({ sel: state?.sel ?? '', sx: state?.sx ?? 0, mine: state?.mine ?? false, ticking: true,
+                       free: state?.free })
   }
 
   const pick = (b: PageBlock | undefined, x = sx) => {
@@ -127,8 +128,10 @@ const PageView: ClientModule<JsonValue, State> = (raw, surface) => {
     } else if (['up', 'down', 'left', 'right'].includes(e.key)) {
       pick(move(page.blocks, picked, e.key))
     } else if (e.key === '[' || e.key === ']') {
-      surface.setState({ sel, sx: across(page, cols, sx + (e.key === '[' ? -STEP : STEP), undefined), mine: true,
+      surface.setState({ sel, sx: across(page, cols, sx + (e.key === '[' ? -STEP : STEP), undefined), mine: true, free: true,
                          ticking: true })
+    } else if (e.key === '-' || e.key === '=' || e.key === '+') {
+      surface.post({ zoomBy: e.key === '-' ? 1 : -1 }) // - shows more of the system, = bigger boxes
     } else if (e.key === 'return') {
       act(picked, 'enter')
     } else if (e.key === ' ') {

{system_diff-0.4.0 → system_diff-0.4.2}/mods/system-diff/hooks/pane.test.tsx

@@ -185,3 +185,15 @@ test('/system-diff close closes the pane, and so does its close button', async (
   expect(closed).toEqual(['system-diff', 'system-diff'])
   await ui.unmount()
 })
+
+test('zoom out draws the diagrams compact, zoom in full again', async ($, on) => {
+  const asked: string[][] = []
+  answer(on, asked)
+  await $.command.run(RUN)
+  const ui = await $.ui.mount({ ...PANE, surface: 'terminal' })
+  await ui.press({ key: 'zoom-out' })
+  expect(asked[asked.length - 1]?.join(' ')).toContain('--zoom 1')
+  await ui.key({ key: '=', in: 'page' })
+  expect(asked[asked.length - 1]?.join(' ')).toContain('--zoom 0')
+  await ui.unmount()
+})

{system_diff-0.4.0 → system_diff-0.4.2}/mods/system-diff/hooks/register.tsx

@@ -14,7 +14,7 @@ import type { Act, Page, Row } from '../types'
 // green what is new, done or to learn, white what to read, gray the background, red only what was taken away.
 
 const PANE = 'system-diff'
-const VERSION = '0.4.0' // the plugin's own, as .claude-plugin/plugin.json says (a test keeps them one)
+const VERSION = '0.4.2' // the plugin's own, as .claude-plugin/plugin.json says (a test keeps them one)
 const WIDEST = 999 // as wide as Claude Code docks a pane: 45% of the terminal
 const COMMANDS = ['system-diff', 'system-diff-pane'] as const
 const VIEWS = [['now', 'Now', 'n'], ['map', 'Map', 'm'], ['agents', 'Agents', 'a'], ['changes', 'Changes', 'c'],
@@ -25,6 +25,9 @@ const view = atom({ plugin: 'system-diff', key: 'view' } as const, 'now', { shap
 const part = atom({ plugin: 'system-diff', key: 'part' } as const, '', { shape: 'part-1' })
 const back = atom({ plugin: 'system-diff', key: 'back' } as const, [] as string[], { shape: 'back-2' })
 const note = atom({ plugin: 'system-diff', key: 'note' } as const, 'Reading the system…', { shape: 'note-1' })
+// How compact the diagrams are: -1 by the pane's width (compact below 110 columns), 0 full, 1 compact, 2 tiny.
+const zoomLevel = atom({ plugin: 'system-diff', key: 'zoom' } as const, -1, { shape: 'zoom-1' })
+const ZOOM_WORD = ['full', 'compact', 'tiny']
 
 // How to run system-diff: the repository's own virtualenv first, then whatever is on PATH.
 const RUNNERS: string[][] = [
@@ -73,6 +76,8 @@ async function refresh($: EngineInterface): Promise<void> {
       again = false
       const argv = ['panel', '--protocol', '2', '--width', String(columns), '--view', await read($, view),
                     '--part', await read($, part)]
+      const level = await read($, zoomLevel)
+      if (level >= 0) argv.push('--zoom', String(level)) // left out, the engine picks by the width (older ones too)
       const got = await run($, argv)
       if (got && !got.old) {
         if (got.out !== last) {
@@ -155,6 +160,13 @@ async function scrollBy($: EngineInterface, rows: number): Promise<void> {
 
 // As wide as Claude Code docks a pane, the first time: a width the person set (dragged, or with the pane's keys:
 // ctrl+x ← →) is theirs from then on.
+// More of the system in the pane (zoom out, +1) or bigger boxes (zoom in, -1), from where the page is drawn now.
+async function zoomBy($: EngineInterface, by: number): Promise<void> {
+  const drawnAt = (await read($, page))?.zoom ?? 0
+  await update($, zoomLevel, () => Math.max(0, Math.min(2, drawnAt + by)))
+  await refresh($)
+}
+
 function open($: EngineInterface) {
   return $.ui.open({ id: PANE, title: 'System diff', columns: WIDEST })
 }
@@ -213,7 +225,7 @@ export const register: Register = on => {
   // What the page (page.tsx) asks for.
   on('ui.message', { component: 'Pane', requestId: PANE }, async ($, e) => {
     const data = (e.data ?? {}) as Act & { back?: boolean; follow?: boolean; width?: number; reveal?: number;
-                                             scrollBy?: number }
+                                             scrollBy?: number; zoomBy?: number }
     if (typeof data.width === 'number' && data.width > 0 && data.width !== columns) {
       columns = data.width
       await refresh($)
@@ -223,6 +235,7 @@ export const register: Register = on => {
     else if (typeof data.learn === 'string') await learn($, data.learn)
     else if (data.back) await goBack($)
     else if (data.follow) await follow($)
+    else if (typeof data.zoomBy === 'number') await zoomBy($, data.zoomBy)
     else if (typeof data.view === 'string') await choose($, data.view)
     return {}
   })
@@ -278,11 +291,14 @@ export const register: Register = on => {
           {behind.length > 0 && (
             <Button key="back" hotkey="b" plain onPress={() => void goBack($)}><Text dimColor>← Back</Text></Button>
           )}
+          <Button key="zoom-out" plain onPress={() => void zoomBy($, 1)}><Text dimColor>⊖</Text></Button>
+          <Text dimColor>{ZOOM_WORD[drawn?.zoom ?? 0] ?? 'full'}</Text>
+          <Button key="zoom-in" plain onPress={() => void zoomBy($, -1)}><Text dimColor>⊕</Text></Button>
           <Button key="close" plain onPress={() => void $.ui.close({ id: PANE })}><Text dimColor>× close</Text></Button>
         </Box>
         {said !== '' && <Text dimColor>{said}</Text>}
         {drawn !== null && Client !== undefined && (
-          <Client key="page" module="./page.tsx" props={{ page: drawn, canGoBack: behind.length > 0 }} />
+          <Client key="page" module="./page.tsx" width="100%" props={{ page: drawn, canGoBack: behind.length > 0 }} />
         )}
         {drawn !== null && Client === undefined && drawn.rows.map(line)}
         {drawn !== null && Client === undefined && (

{system_diff-0.4.0 → system_diff-0.4.2}/mods/system-diff/types/index.d.ts

@@ -24,6 +24,7 @@ export type Page = {
   lights: Record<string, string[]>
   details: Record<string, Row[]>
   pick: string
+  zoom?: number // how compact it is drawn: 0 full, 1 compact, 2 tiny
 }
 
 declare module 'claude-code' {
@@ -34,6 +35,7 @@ declare module 'claude-code' {
       part: Shaped<string>
       back: Shaped<string[]>
       note: Shaped<string>
+      zoom: Shaped<number>
     }
   }
 }

{system_diff-0.4.0 → system_diff-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "system-diff"
-version = "0.4.0"
+version = "0.4.2"
 description = "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."
 readme = "README.md"
 license = "MIT"

{system_diff-0.4.0 → system_diff-0.4.2}/src/system_diff/__init__.py

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

{system_diff-0.4.0 → system_diff-0.4.2}/src/system_diff/agents.py

@@ -24,6 +24,7 @@ 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
 
@@ -33,10 +34,11 @@ def _load(root: Path) -> Dict[str, Any]:
         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 {}}
+                    "agents": data.get("agents") or {}, "ids": data.get("ids") or {},
+                    "warned": data.get("warned") or {}}
     except (OSError, ValueError):
         pass
-    return {"plan": {}, "claims": {}, "agents": {}, "ids": {}}
+    return {"plan": {}, "claims": {}, "agents": {}, "ids": {}, "warned": {}}
 
 
 def _save(root: Path, data: Dict[str, Any]) -> None:
@@ -182,7 +184,60 @@ def after_edit(root: Path, agent_id: str, part: Optional[str], notes: List[Dict[
     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")
-    return {"context": as_context(inbox(root, name)), "warn": warn, "name": name}
+    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]]:

{system_diff-0.4.0 → system_diff-0.4.2}/src/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-0.4.0 → system_diff-0.4.2}/src/system_diff/cli.py

@@ -195,6 +195,7 @@ def parser() -> argparse.ArgumentParser:
     pn.add_argument("--width", type=int, default=80)
     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-0.4.0 → system_diff-0.4.2}/src/system_diff/pane.py

@@ -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 []})
@@ -476,7 +476,19 @@ def view_agents(root: Path, width: int) -> Dict[str, Any]:
     return page.json(view="agents", part="")
 
 
-def show(root: Path, width: int = 80, view: str = "now", part: Optional[str] = None) -> Dict[str, Any]:
+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":

{system_diff-0.4.0 → system_diff-0.4.2}/src/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.4.0 → system_diff-0.4.2}/tests/test_design_and_pane.py

@@ -18,7 +18,7 @@ REFUND = ('from fastapi import APIRouter\nrouter = APIRouter()\n\n\n@router.post
 
 
 def page(capsys, repo, *args):
-    assert main(["--repo", str(repo), "panel", "--width", "100", "--protocol", "2", *args]) == 0
+    assert main(["--repo", str(repo), "panel", "--width", "100", "--protocol", "2", "--zoom", "0", *args]) == 0
     out = json.loads(capsys.readouterr().out)
     return out, ["".join(run[0] for run in row) for row in out["rows"]]
 
@@ -268,3 +268,51 @@ def test_the_agents_tab_shows_each_agent_and_warns_when_two_edit_one_block(repo,
     assert any(t.startswith("THE TEAM  plan: make the API") for t in text)
     assert any("api and store all edit API" in t for t in text)
     assert "● API  @api @st" in "\n".join(text)               # who works where, on the diagram
+
+
+def test_one_agent_editing_two_areas_in_a_turn_is_told_once_to_plan_a_team(repo, files):
+    from system_diff import agent
+
+    def prompt():
+        agent.run_hook(json.dumps({"cwd": str(repo), "hook_event_name": "UserPromptSubmit", "prompt": "go"}),
+                       emit=lambda _s: None)
+
+    def edit(path, text, **who):
+        files(repo, {path: text})
+        said: list = []
+        agent.run_hook(json.dumps({"cwd": str(repo), "hook_event_name": "PostToolUse", "tool_name": "Edit", **who,
+                                   "tool_input": {"file_path": str(repo / path)}}), emit=said.append)
+        outs = [json.loads(s) for s in said]
+        warns = " ".join(o.get("systemMessage", "") for o in outs)
+        context = " ".join(o.get("hookSpecificOutput", {}).get("additionalContext", "") for o in outs)
+        return warns, context
+
+    routes, rules = "app/api/routes.py", "app/core/rules.py"
+    prompt()
+    warns, context = edit(routes, (repo / routes).read_text() + "\n# one\n")
+    assert "areas this turn" not in warns + context              # one area so far
+    warns, context = edit(rules, (repo / rules).read_text() + "\n# one\n")
+    assert "main has edited blocks in 2 areas this turn" in warns and "plan_agents" in warns
+    assert "main has edited blocks in 2 areas this turn" in context and "plan_agents" in context
+    warns, context = edit("app/db/repo.py", (repo / "app/db/repo.py").read_text() + "\n# one\n")
+    assert "areas this turn" not in warns + context              # once a turn
+    prompt()
+    edit(routes, (repo / routes).read_text() + "# two\n")
+    warns, context = edit(rules, (repo / rules).read_text() + "# two\n")
+    assert "areas this turn" in warns and "areas this turn" in context    # a new turn may warn again
+    prompt()
+    for text in ("# a\n", "# b\n"):                            # a subagent staying in its one area
+        warns, context = edit(routes, (repo / routes).read_text() + text, agent_id="a1")
+        assert "areas this turn" not in warns and "a1 has edited" not in context  # main's warning may reach it by bus
+
+
+def test_a_narrow_pane_gets_compact_diagrams_unless_asked_otherwise(repo, capsys):
+    narrow = json.loads(_run(capsys, repo, "--width", "90"))
+    wide = json.loads(_run(capsys, repo, "--width", "140"))
+    assert narrow["zoom"] == 1 and wide["zoom"] == 0
+    assert json.loads(_run(capsys, repo, "--width", "90", "--zoom", "2"))["zoom"] == 2
+
+
+def _run(capsys, repo, *args):
+    assert main(["--repo", str(repo), "panel", "--protocol", "2", *args]) == 0
+    return capsys.readouterr().out