feat(advisor): give every declared binding a caller — 22 unbound → 1

ARCHITECTURE.md

@@ -168,7 +168,7 @@ are ordered by when each starts working:
 
 | Layer | Mechanism | Works from |
 |---|---|---|
-| 1 | `capability_advisor.SURFACE_BINDINGS` — declared, per surface, 3–7 entries, each with its reason; `CONSULT_SITES`, which declares who actually ASKS at each surface; plus `CAPABILITY_PRECONDITIONS`, which explains an offer without changing it | day one; no classifier, no history |
+| 1 | `capability_advisor.SURFACE_BINDINGS` — declared, per surface and per PHASE of a long surface, 3–7 entries each with its reason; `CONSULT_SITES`, which declares who actually ASKS at each surface; plus `CAPABILITY_PRECONDITIONS`, which explains an offer without changing it | day one; no classifier, no history |
 | 2 | `capability_propensity.rank` — orders *within* the bound set by measured usefulness | first resolved trials |
 | 3 | `capability_advisor.learned_associations` — corrects the table from what a surface actually reaches for | once observations accumulate |
 
@@ -494,6 +494,45 @@ finding projection keeps identity and verdict fields only, because `overdue`'s `
 daily on its own and hashing a row whole would score the monitor useful on every run it will ever
 make.
 
+### A DECLARED BINDING WITH NO CALLER IS THE SAME DEFECT AS NO BINDING
+
+Layer 1 is offered to a surface *by that surface's own consult*. So a surface nothing consults is a
+table entry that can never be selected, can never earn evidence, and can never be ranked — the gate
+starving its own drain, one level down from the concealment rule above. Measured 2026-08-23: **22 of
+43 capabilities were bound to NO surface at all**, and two whole surfaces (`ci`, and every phase of
+the tick) had bindings with no caller.
+
+Three callers close that, and the last two are the same mechanism as the first — `advise()` plus the
+`match` heartbeat, never a second one:
+
+| Surface | Caller | What bounds it |
+|---|---|---|
+| `tick` (4 capabilities) | `capability_propensity.tick_evidence` (PR #37) | one verdict per capability per UTC day, gated on artifact regeneration → ~1.3/day |
+| `tick:<phase>` (14 capabilities) | `capability_advisor.py --consult-tick-phases`, at `ORCH-ANCHOR: tick-phase-consult` | consult text stable per (surface, UTC day); the match heartbeat is idempotent on its digest → 34 events on the first tick of a day, 0 on the other 23. **No verdicts at all**, so #37's ceiling is untouched |
+| `ci` (3 capabilities) | `verify.py`'s `ci_consult_line()` — it runs on every PR and already executes the admission gate | `record=False`: a verifier must not write to the ledger its own gates read |
+
+**The tick is sub-surfaced for exactly the reason `repo-audit` is.** 18 of the 43 capabilities live
+on the tick; binding all 18 to `tick` would rebuild the too-many-tools condition inside the tick.
+The five phases — `tick:capacity`, `tick:dispatch`, `tick:experiments`, `tick:redirect`,
+`tick:learning` — are the tick's OWN names, taken from `orchestrate.sh`'s first line ("capacity ->
+discover -> plan -> dispatch"), its `--- Learning cadence ---` heading and its `[cadence] redirect
+…` / `[cadence] experiment follow-up` blocks; most of the capabilities bound below carry a
+`{"kind": "tick_phase", "name": …}` matcher naming the very phase they land in. Each phase resolves
+to 6–8 rather than 18.
+
+**The bare `tick` set does not move, and that is a constraint rather than a preference.**
+`capability_propensity.TICK_SURFACE` is `"tick"`, `tick_evidence()` grades exactly
+`binding_for("tick")`, and its selftest requires every capability with a `TICK_FINDING_FIELDS`
+projection to be in that set. Moving those four into a phase would silently zero the only producer
+of layer-2 evidence in the system — so the phases ADD, and the phase contexts inherit the four
+surface-wide observers for the same reason `repo-audit` declares `offload` surface-wide.
+
+**And a capability no surface may offer says so.** `local-model-profile-trial` is the one ledger row
+that is deliberately unbound — the quarantine-only trial transport — and it is declared with
+`NO_BINDING` and its reason rather than left absent, because silent absence and deliberate emptiness
+must not look alike. The `ci` consult line reports the pair on every PR: rows bound to some surface,
+beside rows bound to none.
+
 **Demotion is the drain.** Bindings that could only grow end with every surface holding all 43 —
 the exact condition binding prevents. Two rules propose removal, and they read **disjoint
 populations**: `never_triggered` counts offers where nothing was said (`not_triggered_silently`)

README.md

@@ -198,6 +198,28 @@ safety switch, not dead code.
   `artifact` are both required (a claimed find with no artifact is worth nothing), and the
   correlated-arm discount is the real guard: ten artifact-backed finds from one judge arm are still
   one observation, so volume cannot inflate a capability and only an independent arm moves it.
+- **The tick is sub-surfaced by phase, and every phase has a caller**
+  (`capability_advisor.py --consult-tick-phases`, every tick, immediately below the step above at
+  `ORCH-ANCHOR: tick-phase-consult`). 18 of the 43 capabilities live on this tick, and binding all
+  18 to one `tick` surface would recreate inside the tick the too-many-tools problem the binding
+  exists to remove. So the tick declares five phases — `tick:capacity`, `tick:dispatch`,
+  `tick:experiments`, `tick:redirect`, `tick:learning`, named from `orchestrate.sh`'s own
+  "capacity -> discover -> plan -> dispatch" line and its `--- Learning cadence ---` /
+  `[cadence] redirect ...` / `[cadence] experiment follow-up` blocks — and each resolves to 6-8
+  capabilities instead of 18. Fourteen capabilities that no surface could offer are now offered
+  where they actually run. The step writes ONLY advisory `match` events and no verdict of any kind,
+  so the ~1.3 verdicts/day above is unchanged: the consult text is stable per (surface, UTC day) and
+  the match heartbeat is idempotent on its digest, which bounds the whole addition to 34 events on
+  the first tick of each day and zero on the other 23. Fails open per phase, always exits 0. Kill
+  switch: `ORCH_DISABLE_STEPS=tick-phase-consult`.
+- **`verify.py` is the `ci` surface and now consults as one.** Three capabilities were declared for
+  a `ci` surface no caller ever reached — the same defect as no binding at all. `verify.py` runs on
+  every PR and already executes the admission gate, so it consults with `surface: "ci"` and prints
+  one summary line carrying both quantities: what the table DECLARES (identical on every machine)
+  beside what this machine's ledger could OFFER, plus the findability pair (rows bound to some
+  surface / rows bound to none). Read-only (`record=False` — a verifier must not write to the
+  ledger its own gates read), never a skip, and it can never enter `problems`, so exit semantics and
+  every reported count are untouched.
 - **`gate_blocks_execution`** — an opt-in capability declaration for the case where a switch blocks
   the code path that would produce an outcome (Thompson never chooses while the mode is
   epsilon-greedy; range-lane's heartbeats sit on the live-apply branch; issue-readiness's label

cadence_registry.py

@@ -127,6 +127,27 @@
         "on those capabilities' own cadences, and a `gradable` of 0 is a "
         "deadlock rather than patience",
     },
+    {
+        # EVERY TICK, deliberately stampless for the same reason as `tick-capability-evidence`
+        # above: the step is a cheap advisory consult, and its bounding comes from the per-(surface,
+        # UTC day) consult digest that makes the match heartbeat idempotent, not from a stamp. It
+        # exists because the tick's FOURTEEN phase-bound capabilities had a declared binding and no
+        # caller -- a binding nothing consults can never be selected, so it can never earn the
+        # evidence that would rank it. Registered here (rather than special-cased in the shell) so
+        # `ORCH_DISABLE_STEPS=tick-phase-consult` is a control that actually works: an unregistered
+        # key WARNs "nothing was disabled by it" while silently disabling the step, which is a
+        # control that lies.
+        "key": "tick-phase-consult",
+        "success_stamp": None,
+        "cadence_days": 0,
+        "artifact": None,
+        "log": "tick-phase-consult.log",
+        "gate": "ORCH_DISABLE_STEPS=tick-phase-consult makes it inert; it records no verdict of any "
+        "kind, so the tick-capability-evidence verdict ceiling is unaffected",
+        "next_transition": "writes at most one advisory `match` event per bound capability per "
+        "phase per UTC day (first tick of the day; nothing on the other 23). A "
+        "phase reporting `offered 0` is a broken binding, not a quiet one",
+    },
     {
         "key": "capability-firing-monitor",
         "success_stamp": ".last-capability-firing-monitor",