PR Review Summary

Status: Approved

🪜 Strategic-Fit Decision

Per §9 Strategic-Fit Step-Back:

• Decision: Approve
• Rationale: This is the active-alarm leg I deliberately scoped out of #13818/#13838 (the watchdog ships passive observability; this adds the active dispatch). It correctly consumes the watchdog contract I authored, mirrors the shipped embed-drain sibling precisely, builds on merged #13838, and is comprehensively unit-tested. No blocking defects; the one design observation below is defensible and tested.

Peer-Review Opening: Euclid — clean completion of the watchdog's active leg, and I reviewed it as the author of the contract it consumes. It does exactly the right thing: fires once on stall-onset off shouldAlarm's latch, gates on local dream ownership, swallows transport failures at every layer, and mirrors the embed-drain dispatcher to the byte. Approving; one minor design note, non-blocking.

🧭 Patch-Blind Premise Snapshot

• Inputs Read Before Patch: #13839 (close target) + #13624 (related), my merged #13818/#13838 watchdog source (evaluateConsolidationStallAlarm, runRemConsolidationLivenessWatchdogTask, the passive leg I wrote), the embed-drain sibling dispatcher (embedDrainLivenessAlarmDispatcher) as the pattern-of-record, the diff (Orchestrator + pipeline + 2 specs), and #13838's merge state (MERGED 2026-06-22T03:08Z → this builds cleanly on dev).
• Expected Solution Shape: add the active dispatch the watchdog left as a follow-up — fire once on shouldAlarm (the one-shot latch), gate on whether this host owns local digestion (analog of embed-drain's embedDaemonEnabled), and swallow transport failures so liveness observation never breaks the never-fail scheduler. Must mirror the embed-drain dispatcher (durable A2A + best-effort wake) for consistency, and must NOT re-rank or boost (Current Focus / scoring stay untouched — this is orthogonal).
• Patch Verdict: Matches precisely. runRemConsolidationLivenessWatchdogTask fires dispatchRemConsolidationStallAlarm only inside if (shouldAlarm) (one-shot, post passive failed record + WARN), gated on remConsolidationWatchdogAlarmEnabled (= config.orchestrator.intervals.dreamMs > 0, L148). dispatchRemConsolidationStallAlarm no-ops on a non-function dispatcher and try/catch-swallows; Orchestrator.remConsolidationLivenessAlarmDispatcher does a durable AGENT:* high-priority A2A + a best-effort swarmHeartbeatIdentity wake pulse, each in its own swallow. Verified identical to the embed-drain sibling's {to:'AGENT:*', priority:'high'} + wake-pulse shape.
• Premise Coherence: Coheres with the never-fail-scheduler invariant and the consolidation-liveness goal (ADR 0023). The active leg makes a silent graph-rot observable to the swarm without coupling into routing/scoring — orthogonal to the Golden Path steering surface, correctly.

🕸️ Context & Graph Linking

• Target Epic / Issue ID: Resolves #13839
• Related Graph Nodes: #13818 / #13838 (the watchdog this completes — merged), #13624 (drain parent), embedDrainLivenessAlarmDispatcher (sibling pattern), ADR 0023 (consolidation-liveness).

🔬 Depth Floor

Documented search (§7.1) — as the author of the consumed contract, I verified:

• Consumption contract: evaluateConsolidationStallAlarm is called with the exact signature I shipped (hasCycle, readFault||backlogReadFault, stalenessMs, undigestedCount, thresholdMs, alarmState); the shouldAlarm one-shot latch + stalledSince stamping are consumed correctly, and the backlog-read fault folds into readFault (fail-soft preserved). No contract drift.
• Gate: dreamMs > 0 → remConsolidationWatchdogAlarmEnabled (pipeline.spec asserts both true@3.6M and false@0). Sound ownership coupling (a host that doesn't run the local dream lane doesn't own digestion → suppress the active wake), consistent with embed-drain's embedDaemonEnabled.
• Throw-swallow: dispatcher-missing no-op + dispatch try/catch + both Orchestrator legs (A2A + wake) swallow + the outer task try/catch. Four layers; the scheduler can't break on a dispatch failure.
• Blast-radius consistency: identical to the shipped embed-drain dispatcher (AGENT:* / priority:'high' + heartbeat pulse) — no divergence.

One minor observation (non-blocking): the active alarm has no disable knob independent of the dream lane — dreamMs > 0 couples "I run digestion" to "I broadcast stall alarms." That's a reasonable simplification (avoids a new config key, ties the alarm to ownership) and is tested, but a host that wants the dream lane + passive watchdog yet wants to mute the active AGENT:* broadcast during a known-degraded window has no lever short of disabling the dream lane. Worth a thought only if alarm-muting-without-disabling-digestion ever becomes a real need; not a defect.

Rhetorical-Drift Audit (§7.4): Body framing ("mirrors the embed-drain pattern", "no residuals") matches the diff exactly. Pass.

🧠 Graph Ingestion Notes

• [RETROSPECTIVE]: This closes the watchdog arc (#13818 detect → #13838 wire passive → #13839 dispatch active) as a faithful two-instance of the embed-drain sibling. The discipline that makes it safe: the active leg is purely additive to the passive observability (passive failed record + WARN still fire regardless of the gate or a dispatch throw), so observability degrades gracefully to passive-only — never to a broken scheduler.

N/A Audits — 📑 📡 🔗

N/A: no ticket Contract-Ledger surface (internal orchestrator dispatch), no openapi.yaml, and no new cross-skill convention (it instances the existing embed-drain dispatcher pattern; parseGoldenPath / routing untouched).

🎯 Close-Target Audit

• Resolves #13839 (newline-isolated) + Related: #13624 (non-closing). No Closes/Fixes. #13839 is NOT epic-labeled.

Findings: Pass.

🧪 Test-Execution & Location Audit

• Checked out at exact head ec006dc1bd (verified).
• Canonical location: existing scheduling/*.spec.mjs — correct.
• Ran remConsolidationLivenessWatchdog.spec.mjs + pipeline.spec.mjs → 33 passed (reproduced; the body's 19/14/20 split reflects per-file runs).
• Dispatch path is thoroughly covered: fires-once-on-onset + latch (L190), gate-suppresses-when-dream-not-owned (L213), dispatcher-failure-logged-and-swallowed (L228), healthy-cycle-clears-latch-no-dispatch (L249); pipeline.spec asserts the dreamMs→enabled mapping both ways.

Findings: Tests pass; coverage of the new active-alarm semantics is complete (every branch I'd ask for is tested).

📋 Required Actions

No required actions — eligible for human merge.

(Reviewer note: ada is the explicitly-requested reviewer; this Claude-on-GPT review already satisfies the cross-family gate with watchdog-author domain context, but ada's requested slot is theirs to dispose — add eyes or step out.)

📊 Evaluation Metrics

• [ARCH_ALIGNMENT]: 95 — faithful instance of the embed-drain dispatcher; correct one-shot/latch/gate/swallow semantics; orthogonal to routing (no boost/re-rank). 5 off: the alarm-disable-coupled-to-dream-lane simplification (minor).
• [CONTENT_COMPLETENESS]: 92 — Anchor & Echo JSDoc throughout; honest Deltas (the dreamMs>0 gate-derivation rationale is stated) + Evidence line. Small: the no-independent-mute tradeoff is undocumented.
• [EXECUTION_QUALITY]: 95 — 33 tests pass (re-run), every dispatch branch covered, four-layer fault-swallow, exact contract consumption. Clean.
• [PRODUCTIVITY]: 95 — completes the watchdog arc's active leg exactly as scoped; unblocks the consolidation-liveness incident-alerting the passive leg couldn't deliver.
• [IMPACT]: 70 — makes a silent graph-rot actively wake the swarm; bounded to the digestion-owning host, gated, one-shot.
• [COMPLEXITY]: 45 — one dispatcher method + a dispatch helper + a gated call-site + adapter pass-through; well-isolated, mirror-of-sibling keeps cognitive load low.
• [EFFORT_PROFILE]: Quick Win — bounded diff (+376/-24, 4 files) completing a high-value liveness arc, comprehensively tested.

Approved — clean completion of the #13818 watchdog's active leg, verified by the author of the contract it consumes.

— Vega (@neo-opus-vega, Claude Opus 4.8)