The collision radar

Workspace → Collision Radar.

This is the during half of the product. When one agent invalidates another, the other one is told.

What the detection actually is

A join, not a judgement. It compares what one session moved against what another session is standing on.

• What a session moved comes from the symbols reported on its change sets — and preferably from symbols derived from the diff rather than claimed by the agent.
• What a session is standing on comes from its recorded dependencies.

Nothing here calls a model. It is deterministic, explainable, and cheap enough to run on every change report.

A collision is only raised between live sessions. A session that has ended is not standing on anything.

What a collision records

Field	What it holds
Source session	The session that moved the ground.
Affected session	The session standing on it.
Symbol and path	What moved.
Severity	high, medium or low — how certain we are the affected work is invalid.
Detail	The sentence a person reads.
Status	open, rebriefed, accepted, resolved or stale.

The detail is assembled to be read, not parsed:

the shape of ClaimsService.GetDocument changed, and the other session has tests against it — it was given this symbol when it was briefed.

The three shapes of what moved: "{symbol} was removed", "the shape of {symbol} changed", "{symbol} was modified". The four relations: has tests against it, implements it, extends it, is building against it.

A repeat detection of the same pair and symbol refreshes the existing record rather than making a second one.

The two-sided view

Opening a collision shows it as the two sides rather than as a diff, because a diff cannot say it:

"The shape changed from Stream to ExportResult, and Agent 07 is writing callers for Stream" is not something a diff can say — the two facts live in different branches and neither file mentions the other.

It shows what changed, what the other session expected, and a recommended action:

Re-brief Agent 07. It is building against the previous shape of ClaimsService.GetDocument and nothing in its own work will reveal that.

or, when the other side is gone:

Agent 07 has ended, so there is nothing live to re-brief.

Where the record is thin, it says so rather than showing an empty panel: "The symbol change was not recorded in detail — only that it happened." and "It did not declare this dependency; Madebook inferred it from what it read."

What each side is told

The session that made the change is told, and told not to stop:

Another session is building against {symbol}. Madebook is re-briefing it; you do not need to stop.

That is deliberate. Stopping the session that made the change is the wrong end — it did nothing wrong. The session building on the old shape is the one that needs the re-brief.

The affected session loses points on its dependencies_current health dimension — 45 for a high-severity collision, 15 otherwise — and a high-severity one recommends a re-brief regardless of its overall floor.

In the attention queue

Severity	Disposition	Urgency
high	intervene	95
anything else	review	65

Headline: "{source} changed {symbol}; {affected} is building against it." Body: the detail, then "{affected} has been working since 14:07 and does not know this changed. Its work is being built on an assumption that no longer holds."

An item is suppressed entirely once the affected session is no longer live — an alert about it is exactly the stale noise that makes queues unreadable.

Two actions: Re-brief the affected agent, or Let it continue.

Blast radius

Each collision carries a blast radius: how many indexed files share a module with the changed files.

It is an honest proxy, and the code says why: without an import graph, module co-location is the nearest thing to the truth that can actually be computed.

What a person can do

There is no kill switch anywhere in Madebook. What you have is:

• Re-brief the affected session, which marks the collision as re-briefed.
• Let it continue, which accepts it.
• Pause the affected session from its own page, which tells it to stop the next time it checks in.

A collision on a session that then ends is closed automatically as stale: "{label} ended before this was resolved."

Related

• Work sessions — context health.
• The attention queue
• Changes and review capsules