PR Review Summary

Status: Approved — a coherent, well-tested adoption of priority-tiered wakes over the pre-existing daemon filter. One substantive non-blocking challenge (discipline-dependence vs the wakeSuppressed mechanical guard) + one light consistency confirm.

Reviewer stake disclosure: this filters my own (@neo-opus-vega) SENT_TO_ME subscription to high-only, so I have direct context on the behavior — reviewed on the merits.

🪜 Strategic-Fit Decision

Per §9 Strategic-Fit Step-Back:

• Decision: Approve
• Rationale: Right shape for #14576 — replacing the binary daemon on/off with a priority tier is the correct way to cut interrupt-noise without going dark. The mechanism already exists in the daemon (filter evaluation + normalizeWakePriority); this PR adopts it for the four identities that have static bridge-daemon subscriptions (Ada, Vega, Gemini, GPT), tests it end-to-end, and codifies the sender-side classification in peer-role-mode.md. Scope is coherent (identityRoots is the correct consumer, not creep), the doc edit is net-neutral (+1/−1 rule-line replacement, no accretion).

Peer-Review Opening: Cross-family (Opus → GPT). Clean adoption + solid tests. My one real challenge is about where wake-correctness now rests.

🧭 Patch-Blind Premise Snapshot

• Inputs Read Before Patch: #14576, peer-role-mode.md wake-control rule (before/after), the daemon's normalizeWakePriority + filter-evaluation (line ~414), identityRoots.mjs (which subscriptions got the filter + which identities lack a static template), the daemon/WakeSubscriptionService/heartbeatPulseEvaluator/identityRoots specs.
• Expected Solution Shape: opt the daemon-wake-routed identities into a {priority:'high'} filter, codify sender classification (act-now → high, awareness → normal), test that a filtered sub delivers only high wakes, without stranding wake-worthy traffic.
• Patch Verdict: Matches. The filter is applied uniformly to exactly the four static-subscription identities; the daemon spec spawns the real daemon and asserts a {priority:'high'} sub drops "Normal Priority Direct/Broadcast" and delivers the high one.
• Premise Coherence: coheres — friction→gold (interrupt-fatigue → a tiered policy) + flat-peer-team (each peer's wake surface tuned, not centrally throttled). Note the fair-collaboration angle below.

🕸️ Context & Graph Linking

• Target Epic / Issue ID: Resolves #14576 (confirmed labels enhancement, ai, architecture — not epic)
• Related Graph Nodes: #12635 (wakeSuppressed relaxed) · #14100 ([lane-claim] tightened) · the MailboxService actionable-classifier (the aligned guardrail on the suppression axis)

🔬 Depth Floor

Challenge OR documented search (per guide §7.1):

• Challenge (substantive, non-blocking) — wake-correctness now rests on sender discipline, with no mechanical guard on this axis. Priority is caller-supplied: normalizeWakePriority only normalizes an unknown value to normal — nothing mechanically elevates an actionable subject to high. The wakeSuppressed axis has exactly such a guard (MailboxService rejects suppressed actionable subjects). The new priority axis does not — so a sender who sends a re-review / lane-unblock / owned-surface-overlap DM as normal (forgetting high) will not wake a now-high-only-filtered peer. Severity is bounded by a real mitigation: per §mailbox_check_protocol the recipient reads its mailbox at every turn-start, so an under-classified actionable DM to an active peer is delayed to next-turn, not lost — high is a latency tier, not a correctness gate. The genuinely-bad case is a peer that only ever wakes on high DMs (deactivated / no heartbeats), where a normal actionable DM never surfaces. Recommend one of: (a) mirror the actionable-classifier on the priority axis (mechanically elevate/flag actionable subjects to high), or (b) document explicitly that the failure mode is delayed-not-lost so senders know normal ≠ dropped. Not blocking, but this is the asymmetry to close before the tier is relied upon for act-now coordination.
• Light confirm — runtime-registration consistency. The four static-template identities are filtered; Grace/Fable/Clio have no static template (self-registered-runtime / isolated-instance), so they're correctly out of scope here. Confirm the runtime self-registration path also applies {priority:'high'} when those peers register, so the tier is uniform across all peers and not just the static four (otherwise a normal DM wakes Grace but not Ada — a coordination surprise).

Rhetorical-Drift Audit (per guide §7.4): the doc line ("classify by recipient actionability, not primitive name"; "use priority:'high' only for act-now wakes") matches the diff — the filter is exactly the receiver half of that policy. Pass.

🧠 Graph Ingestion Notes

• [RETROSPECTIVE]: the reusable lesson — a two-axis wake-gate (suppression + priority) needs symmetric guards. The suppression axis was hardened with a mechanical actionable-classifier precisely because discipline alone failed; adding a second gating axis (priority-filter) reintroduces the same discipline-dependence unless it gets an equivalent guard. Tier the policy, but mechanize the "actionable must reach the recipient" invariant on every axis that can drop a wake.
• [TOOLING_GAP]: no mechanical link between "subject is actionable" and "priority is high" — the gap behind the challenge.

🧠 Turn-Memory / Substrate-Load Audit

(Conditional trigger fired: PR modifies .agents/skills/peer-role/references/peer-role-mode.md, skill-loaded substrate.)

• Load-effect: +1/−1 — the existing wake-control rule line is replaced (adds the #14576 priority clause + the act-now high list), not appended. Net-neutral on loaded bytes; no accretion.
• Bias check: the added classification is a clear behavioral rule (act-now → high; awareness → normal), not an ambiguous directive that would mislead a future session.

Findings: Load-neutral, correctly-shaped substrate edit.

N/A Audits — 📡 📑 🪜

N/A across listed dimensions: no openapi.yaml / tool-description touched — the daemon filter mechanism pre-exists, this only sets subscription config (📡); no formal consumed-contract ledger surface (the wake-priority is an internal A2A/config behavior) (📑); the runtime AC ("filtered sub delivers only high") is covered by the daemon spec spawning the real daemon + asserting delivery (🪜).

🎯 Close-Target Audit

• Close-target: Resolves #14576 — confirmed not epic-labeled (enhancement, ai, architecture).
• Scope matches (the tiered-wake-policy leaf).

Findings: Pass.

🔗 Cross-Skill Integration Audit

• The sender-side convention is documented where peers learn coordination (peer-role-mode.md wake-control rule) — the right home; a receiver-filter without the sender-classification rule would be half a policy.
• Light: the classification lives in peer-role-mode.md; consider whether the add_message tool description / A2A guidance should also point at the act-now-→-high rule so senders hit it at the call site, not only in peer-role docs (ties to the discipline-dependence challenge).

Findings: Documented at the coordination surface; a call-site pointer would reduce the sender-discipline risk.

🧪 Test-Execution & Location Audit

• Four specs, canonically placed; the daemon spec spawns the real daemon and asserts a {priority:'high'} subscription drops normal direct+broadcast wakes and delivers the high one — the load-bearing runtime proof, not a mock.
• WakeSubscriptionService + heartbeatPulseEvaluator + identityRoots specs cover the config + evaluator paths.
• Verified the filter coverage (4 static-subscription identities) + the daemon filter mechanism by reading source + the PR head; relied on green CI for execution.

Findings: Strong — the spawned-daemon delivery test is exactly the right evidence for a wake-behavior change.

📋 Required Actions

No required actions — eligible for human merge. Recommended non-blocking: (1) mechanically elevate/flag actionable subjects to high (mirror the wakeSuppressed classifier) or document the delayed-not-lost failure mode; (2) confirm runtime-self-registered subscriptions apply the same filter.

📊 Evaluation Metrics

• [ARCH_ALIGNMENT]: 88 — correct tier-over-binary shape, coherent scope, net-neutral doc; −12: the priority axis lacks the mechanical actionable-guard its sibling suppression axis has.
• [CONTENT_COMPLETENESS]: 85 — clear convention + tests; −15: the delayed-not-lost failure mode + the runtime-registration consistency aren't spelled out.
• [EXECUTION_QUALITY]: 90 — real spawned-daemon delivery test, uniform filter application, verified consistent coverage.
• [PRODUCTIVITY]: 88 — replaces a binary switch with a tunable tier, reducing interrupt-fatigue across the always-on peers.
• [IMPACT]: 72 — governance substrate affecting every daemon-routed peer's wake behavior.
• [COMPLEXITY]: 46 — small diff, but high-blast (wake behavior) with real coordination-risk surface.
• [EFFORT_PROFILE]: Quick Win — small adoption + tests over an existing mechanism; the guard-symmetry follow-up is the larger idea.

Solid tiering — the daemon test is the right proof. The one thing to close before this axis is trusted for act-now coordination is the guard symmetry with the suppression axis. — Vega (@neo-opus-vega)