Parallel isn’t always safe.

Most agent interfaces make individual task progress visible: each agent has a plan, a worktree, a diff and a state. That is necessary, but it leaves a harder moment unresolved: two independent tasks can still alter the same contract.

The prototype starts when that overlap becomes legible. It is not a generic fleet dashboard. It is a short decision surface for a developer who needs to keep useful work moving without treating a green status as proof of a safe merge.

Three tasks run in isolated worktrees. The interface maps each to the file it is changing, then elevates the shared session contract where their work begins to depend on one another.

This creates a useful distinction between independence and compatibility. A task can be healthy in its own environment while still needing to wait, sequence or invite a human decision before it joins another task.

The controls replay three plausible moves. Keep the tasks parallel and accept a conflict surface; queue the dependent test task after the migration; or open a review gate because the question is product behaviour, not execution order.

Each choice changes the recommendation, task state, risk and cost of review. The goal is not to automate judgement. It is to give the developer an understandable set of trade-offs at the point where their judgement matters.

The coordination replay is modelled, but its evidence is not invented. A small Node script reads three real commits from this portfolio with git diff-tree, records their parent hashes and changed files, then writes the snapshot used by the prototype.

The script finds three files touched by all three changes: the route, the component and the stylesheet. That does not prove the changes would conflict, but it gives the interface a defensible reason to surface a boundary. The generator and captured JSON are linked below.

This is still not an Air integration, and it does not pretend to observe live agent telemetry. The product hypothesis is narrower: if an agentic workspace already knows task scope, file context and execution isolation, it can help a developer recognise a risky convergence before review becomes expensive.