[coordination][deferred] First-class delegate(target, goal) registry primitive

[serge-ivo]

DEFERRED (do after the near-term Overseer→Pilot ships + proves out). Extract the near-term goal-delegation mechanism into a general delegate(target, goal) registry tool — target = a repo's Pilot now, an instance/agent later. One delegate verb that picks the level (Engine one-shot vs Pilot goal vs agent goal), collapsing the three overlapping drive-paths (send_to_cli / Loop / drive_claude). Part of #154. Design: docs/coordination-primitives.md.

[serge-ivo]

Un-deferred — this is now the critical path

#154 deferred this until the near-term Overseer→Pilot work (#155) shipped and proved out. It did, and a second consumer has arrived: configurable multi-layer supervision (#183), where a user wires agents to oversee other agents.

This ticket is the smallest useful first step of that, and everything else depends on it. The blocking detail is a type:

drive_claude(repoId, instruction)      // target is a REPO

The delegation target is typed as a repo, which is precisely why the hierarchy cannot leave Coder. Generalizing the target to an addressable supervisable entity (an instance, or a repo's Pilot) is the change that unlocks #183, #159 and the rest.

Design: docs/supervision.md. Sequencing: this → #183 (graph as data) + #184 (budget) + #185 (authority) → #157 (typed task/result) → #159 falls out.

[serge-ivo]

Landed in ef1099a.

What shipped — lib/delegate-target.ts:

type DelegationTarget =
  | { kind: "repo"; repoId: string }          // a repo's Pilot — live today
  | { kind: "instance"; instanceId: string }  // another agent's brain — parsed, not executable

delegateGoal → delegateToTarget, and it now resolves the target itself rather than being handed a pre-resolved session + repo. That is the real generalization: the overseer route no longer knows how to find a repo, so a second target kind slots in without the route learning anything about it.

Deliberately not executable for instance yet. It parses and validates, then is refused at dispatch with an explicit reason — running it needs #183 (supervision graph), #184 (budget) and #185 (authority containment), without which agent-to-agent delegation is an unbounded loop and a consent bypass. A silent no-op was the wrong alternative: it would leave a board card that looks delegated and never moves.

Behaviour-preserving. The legacy {repoId} shape the drive_claude tool still emits keeps parsing, so an in-flight model call works unchanged; every user-facing string is identical. The board record's repoName became targetLabel so the card need not be re-shaped per target kind — rendered text for repos is byte-identical.

11 new tests on the pure module (including "returns null rather than guessing a target" — a wrong default would spend real money somewhere the caller never named). Full API suite 1531 passing, typecheck clean.

Next per docs/supervision.md: #158 (durable loop) in parallel, then #183 + #184 + #185 together.

[serge-ivo]

Done in ef1099a. Delegation is addressed by target ({kind:"repo"|"instance"}) and delegateToTarget resolves it itself, so the route no longer knows how to find a repo. Routing by declared capability landed in c9f093f — the 'one delegate verb that picks the level' this ticket asked for.