reflectt-node 0.1.0

package/dist/health.js

@@ -0,0 +1,1841 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) Reflectt AI
+/**
+ * Team Health Monitoring
+ *
+ * Real-time team health diagnostics:
+ * - Silence detection (>3 heartbeats = ~45min)
+ * - Blocker tracking from messages
+ * - Overlapping work detection
+ * - Collaboration compliance (protocol v1)
+ */
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { presenceManager } from './presence.js';
+import { chatManager } from './chat.js';
+import { taskManager } from './tasks.js';
+import { routeMessage } from './messageRouter.js';
+import { resolveIdleNudgeLane } from './watchdog/idleNudgeLane.js';
+import { getDb } from './db.js';
+import { policyManager } from './policy.js';
+import { recordSystemLoopTick } from './system-loop-state.js';
+/**
+ * Validate a task timestamp is within reasonable bounds.
+ * Rejects: 0, negative, NaN, future timestamps (>1h ahead), impossibly old (>1 year).
+ * Returns the validated timestamp or null if invalid.
+ */
+export function validateTaskTimestamp(ts, now) {
+    const n = Number(ts);
+    if (!n || !Number.isFinite(n) || n <= 0)
+        return null;
+    const currentTime = now ?? Date.now();
+    const ONE_HOUR_MS = 60 * 60 * 1000;
+    const ONE_YEAR_MS = 365 * 24 * 60 * 60 * 1000;
+    if (n > currentTime + ONE_HOUR_MS)
+        return null;
+    if (n < currentTime - ONE_YEAR_MS)
+        return null;
+    return n;
+}
+/**
+ * Verify a task still exists and is in an active (non-deleted, non-done) state.
+ * Returns the fresh task if valid, null otherwise.
+ */
+export function verifyTaskExists(taskId) {
+    try {
+        const task = taskManager.getTask(taskId);
+        if (!task)
+            return null;
+        if (task.status === 'done')
+            return null;
+        return task;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Compute per-agent active lane from task board + presence data.
+ * Priority: doing > blocked > validating > offline > queue-clear
+ */
+export function computeActiveLane(agentName, tasks, presenceStatus, lastSeenMs, offlineThresholdMs = 15 * 60 * 1000, now = Date.now()) {
+    const agent = agentName.toLowerCase();
+    const agentTasks = tasks.filter(t => (t.assignee || '').toLowerCase() === agent);
+    if (agentTasks.some(t => t.status === 'doing'))
+        return 'doing';
+    if (agentTasks.some(t => t.status === 'blocked'))
+        return 'blocked';
+    if (agentTasks.some(t => t.status === 'validating'))
+        return 'validating';
+    // Check if offline via presence
+    if (presenceStatus === 'offline')
+        return 'offline';
+    if (lastSeenMs !== undefined && lastSeenMs > 0 && (now - lastSeenMs) >= offlineThresholdMs)
+        return 'offline';
+    return 'queue-clear';
+}
+class TeamHealthMonitor {
+    blockerKeywords = [
+        'blocked',
+        'blocker',
+        'waiting on',
+        'waiting for',
+        'need help',
+        'stuck',
+        'can\'t',
+        'unable to',
+        'no access',
+        'missing',
+    ];
+    healthHistory = [];
+    MAX_HISTORY = 168; // 7 days at hourly snapshots
+    lastSnapshotTime = 0;
+    SNAPSHOT_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+    trioAgents = ['kai', 'link', 'pixel'];
+    workerAgents = ['link', 'pixel'];
+    workerCadenceMaxMin = 45;
+    leadCadenceMaxMin = 60;
+    blockedEscalationMin = 20;
+    trioSilenceMaxMin = 60;
+    // System idle nudge settings (configurable via env)
+    idleNudgeEnabled = process.env.IDLE_NUDGE_ENABLED !== 'false';
+    idleNudgeWarnMin = Number(process.env.IDLE_NUDGE_WARN_MIN || 45);
+    idleNudgeEscalateMin = Number(process.env.IDLE_NUDGE_ESCALATE_MIN || 60);
+    idleNudgeCooldownMin = Number(process.env.IDLE_NUDGE_COOLDOWN_MIN || 20);
+    idleNudgeSuppressRecentMin = Number(process.env.IDLE_NUDGE_SUPPRESS_RECENT_MIN || 20);
+    idleNudgeShipCooldownMin = Number(process.env.IDLE_NUDGE_SHIP_COOLDOWN_MIN || 30);
+    idleNudgeActiveTaskMaxAgeMin = Number(process.env.IDLE_NUDGE_ACTIVE_TASK_MAX_AGE_MIN || 180);
+    idleNudgeExcluded = new Set((process.env.IDLE_NUDGE_EXCLUDE || 'ryan,diag')
+        .split(',')
+        .map(s => s.trim().toLowerCase())
+        .filter(Boolean));
+    idleNudgeState = new Map();
+    idleNudgeLastDecisions = [];
+    cadenceWatchdogEnabled = process.env.CADENCE_WATCHDOG_ENABLED !== 'false';
+    cadenceSilenceMin = Number(process.env.CADENCE_SILENCE_MIN || 60);
+    cadenceWorkingStaleMin = Number(process.env.CADENCE_WORKING_STALE_MIN || 45);
+    cadenceWorkingTaskMaxAgeMin = Number(process.env.CADENCE_WORKING_TASK_MAX_AGE_MIN || 240);
+    cadenceAlertCooldownMin = Number(process.env.CADENCE_ALERT_COOLDOWN_MIN || 30);
+    /** Grace period after service start — suppress cadence alerts to avoid restart-triggered batch spam */
+    cadenceStartupGraceMs = Number(process.env.CADENCE_STARTUP_GRACE_MS || 10 * 60_000);
+    /** Window for rate-limit failure message suppression (ms) */
+    cadenceRateLimitSuppressMs = Number(process.env.CADENCE_RATE_LIMIT_SUPPRESS_MS || 20 * 60_000);
+    cadenceAlertState = new Map();
+    staleDoingThresholdMin = Number(process.env.STALE_DOING_THRESHOLD_MIN || 240);
+    // Mention rescue fallback: if Ryan pings trio and nobody replies quickly, emit a direct system ack.
+    mentionRescueEnabled = process.env.MENTION_RESCUE_ENABLED !== 'false';
+    // Default delay is intentionally non-zero to avoid noisy immediate fallback nudges.
+    // We also clamp to a minimum to prevent misconfig (e.g. env="0") from spamming #general.
+    // Override with MENTION_RESCUE_DELAY_MIN to increase (values <3 are treated as 3).
+    mentionRescueDelayMin = (() => {
+        const raw = process.env.MENTION_RESCUE_DELAY_MIN;
+        const parsed = (raw === undefined || raw.trim() === '') ? 5 : Number(raw);
+        const val = Number.isFinite(parsed) ? parsed : 5;
+        return Math.max(3, val);
+    })();
+    mentionRescueCooldownMin = Number(process.env.MENTION_RESCUE_COOLDOWN_MIN || 10);
+    mentionRescueGlobalCooldownMin = Number(process.env.MENTION_RESCUE_GLOBAL_COOLDOWN_MIN || 5);
+    /** Maps mentionId → { lastRescueAt, rescueCount }. Once rescued, won't rescue again (one-shot). */
+    mentionRescueState = new Map();
+    mentionRescueLastAt = 0;
+    /** Thread-level idempotency: tracks which thread keys have been rescued (persisted in SQLite). */
+    mentionRescueDbInitialized = false;
+    systemStartTime = Date.now();
+    requestCount = 0;
+    errorCount = 0;
+    requestTimes = [];
+    MAX_REQUEST_TIMES = 1000;
+    /**
+     * Get comprehensive team health snapshot
+     */
+    async getHealth() {
+        const now = Date.now();
+        const agents = await this.getAgentHealthStatuses(now);
+        const blockers = await this.extractBlockers();
+        const overlaps = await this.detectOverlaps();
+        const compliance = await this.getCollaborationCompliance(now);
+        const staleDoing = this.getStaleDoingSnapshot(now);
+        const silentAgents = agents
+            .filter(a => a.status === 'silent')
+            .map(a => a.agent);
+        const activeAgents = agents
+            .filter(a => a.status === 'active')
+            .map(a => a.agent);
+        return {
+            timestamp: now,
+            agents,
+            blockers,
+            overlaps,
+            silentAgents,
+            activeAgents,
+            compliance,
+            staleDoing,
+        };
+    }
+    getTaskLastActivityAt(taskId, fallbackUpdatedAt) {
+        const comments = taskManager.getTaskComments(taskId);
+        const latestCommentAt = comments.reduce((max, c) => Math.max(max, this.parseTimestamp(c.timestamp)), 0);
+        return Math.max(fallbackUpdatedAt, latestCommentAt);
+    }
+    extractTaskPrLink(task) {
+        if (!task?.metadata || typeof task.metadata !== 'object')
+            return null;
+        const metadata = task.metadata;
+        const candidates = [];
+        const directPrUrl = metadata.pr_url;
+        const directPrLink = metadata.pr_link;
+        if (typeof directPrUrl === 'string')
+            candidates.push(directPrUrl);
+        if (typeof directPrLink === 'string')
+            candidates.push(directPrLink);
+        const artifacts = metadata.artifacts;
+        if (Array.isArray(artifacts)) {
+            for (const item of artifacts) {
+                if (typeof item === 'string')
+                    candidates.push(item);
+            }
+        }
+        const qaBundle = metadata.qa_bundle;
+        if (qaBundle && typeof qaBundle === 'object') {
+            const artifactLinks = qaBundle.artifact_links;
+            if (Array.isArray(artifactLinks)) {
+                for (const item of artifactLinks) {
+                    if (typeof item === 'string')
+                        candidates.push(item);
+                }
+            }
+        }
+        const pullUrlRegex = /https?:\/\/github\.com\/[^\s/]+\/[^\s/]+\/pull\/\d+(?:[^\s]*)?/i;
+        for (const candidate of candidates) {
+            const trimmed = candidate.trim();
+            if (!trimmed)
+                continue;
+            const match = trimmed.match(pullUrlRegex);
+            if (match)
+                return match[0];
+        }
+        return null;
+    }
+    getStaleDoingSnapshot(now = Date.now()) {
+        const doing = taskManager.listTasks({ status: 'doing' });
+        const MAX_STALE_DISPLAY_MIN = 24 * 60;
+        const staleTasks = doing
+            .filter(task => Boolean(task.assignee))
+            // Verify task still exists (guards against stale cache / deleted tasks)
+            .filter(task => verifyTaskExists(task.id) !== null)
+            .map((task) => {
+            const lastActivityAt = this.getTaskLastActivityAt(task.id, this.parseTimestamp(task.updatedAt));
+            // Validate timestamp bounds — cap impossible ages
+            const validatedAt = validateTaskTimestamp(lastActivityAt, now);
+            const staleMinutes = validatedAt
+                ? Math.min(Math.max(0, Math.floor((now - validatedAt) / 60_000)), MAX_STALE_DISPLAY_MIN)
+                : MAX_STALE_DISPLAY_MIN;
+            return {
+                task_id: task.id,
+                assignee: task.assignee || 'unassigned',
+                title: task.title,
+                stale_minutes: staleMinutes,
+                last_activity_at: lastActivityAt,
+            };
+        })
+            .filter(task => task.stale_minutes >= this.staleDoingThresholdMin)
+            .sort((a, b) => b.stale_minutes - a.stale_minutes);
+        return {
+            thresholdMinutes: this.staleDoingThresholdMin,
+            count: staleTasks.length,
+            tasks: staleTasks,
+        };
+    }
+    async getAgentHealthSummary(now = Date.now()) {
+        const agents = await this.getAgentHealthStatuses(now);
+        const allTasks = taskManager.listTasks({});
+        const healthyMaxMs = 45 * 60 * 1000;
+        const stuckMinMs = 60 * 60 * 1000;
+        const offlineMinMs = 120 * 60 * 1000;
+        const rows = agents.map((agent) => {
+            const heartbeatAgeMs = Math.max(0, agent.minutesSinceLastSeen) * 60_000;
+            let state = 'healthy';
+            let staleReason = null;
+            if (agent.lastSeen <= 0 || heartbeatAgeMs >= offlineMinMs) {
+                state = 'offline';
+                staleReason = 'offline-no-heartbeat';
+            }
+            else if (agent.idleWithActiveTask && heartbeatAgeMs >= stuckMinMs) {
+                state = 'stuck';
+                staleReason = 'active-task-idle-over-60m';
+            }
+            else if (heartbeatAgeMs > healthyMaxMs) {
+                state = 'idle';
+                staleReason = 'heartbeat-age-over-45m';
+            }
+            const presenceStatus = state === 'offline' ? 'offline' : undefined;
+            const activeLane = computeActiveLane(agent.agent, allTasks, presenceStatus, agent.lastSeen, offlineMinMs, now);
+            return {
+                agent: agent.agent,
+                last_seen: agent.lastSeen,
+                active_task: agent.currentTask || null,
+                heartbeat_age_ms: heartbeatAgeMs,
+                last_shipped_at: agent.lastProductiveAt,
+                shipped_age_ms: agent.minutesSinceProductive === null ? null : Math.max(0, agent.minutesSinceProductive) * 60_000,
+                stale_reason: staleReason,
+                idle_with_active_task: agent.idleWithActiveTask,
+                state,
+                active_lane: activeLane,
+            };
+        });
+        return {
+            agents: rows,
+            thresholds: {
+                healthyMaxMs,
+                stuckMinMs,
+                offlineMinMs,
+            },
+            timestamp: now,
+        };
+    }
+    async getCollaborationCompliance(now = Date.now()) {
+        const tasks = taskManager.listTasks({});
+        const messages = chatManager.getMessages({ limit: 300 });
+        const incidents = await this.getComplianceIncidents(now, messages);
+        const complianceAgents = this.trioAgents.map((agent) => {
+            const expectedCadenceMin = agent === 'kai' ? this.leadCadenceMaxMin : this.workerCadenceMaxMin;
+            const lastValidStatusAt = this.findLastValidStatusAt(messages, agent);
+            const lastValidStatusAgeMin = lastValidStatusAt
+                ? Math.floor((now - lastValidStatusAt) / 1000 / 60)
+                : 9999;
+            let state = 'ok';
+            if (lastValidStatusAgeMin > expectedCadenceMin) {
+                state = 'violation';
+            }
+            else if (lastValidStatusAgeMin >= Math.max(0, expectedCadenceMin - 10)) {
+                state = 'warning';
+            }
+            const hasEscalation = incidents.some(i => i.agent === agent);
+            if (hasEscalation) {
+                state = 'escalated';
+            }
+            const activeTask = tasks.find(t => t.assignee === agent && t.status === 'doing');
+            return {
+                agent,
+                taskId: activeTask?.id || null,
+                lastValidStatusAt,
+                lastValidStatusAgeMin,
+                expectedCadenceMin,
+                state,
+            };
+        });
+        const workerWorstAgeMin = Math.max(...complianceAgents
+            .filter(a => this.workerAgents.includes(a.agent))
+            .map(a => a.lastValidStatusAgeMin), 0);
+        const leadAgeMin = complianceAgents.find(a => a.agent === 'kai')?.lastValidStatusAgeMin ?? 9999;
+        const blockerMessages = messages.filter(m => typeof m.content === 'string'
+            && /\bblocker\s*:\s*(?!none|no|n\/a|na\b).+/i.test(m.content)
+            && this.trioAgents.includes((m.from || '').toLowerCase()));
+        const oldestBlockerMin = blockerMessages.length > 0
+            ? Math.max(...blockerMessages.map(m => Math.floor((now - (m.timestamp || now)) / 1000 / 60)))
+            : 0;
+        const lastTrioGeneralUpdate = this.findLastTrioGeneralUpdate(messages);
+        const trioSilenceMin = Math.floor((now - lastTrioGeneralUpdate) / 1000 / 60);
+        return {
+            summary: {
+                workerCadenceMaxMin: this.workerCadenceMaxMin,
+                leadCadenceMaxMin: this.leadCadenceMaxMin,
+                blockedEscalationMin: this.blockedEscalationMin,
+                trioSilenceMaxMin: this.trioSilenceMaxMin,
+                workerWorstAgeMin,
+                leadAgeMin,
+                oldestBlockerMin,
+                trioSilenceMin,
+            },
+            agents: complianceAgents,
+            incidents,
+        };
+    }
+    parseTimestamp(value) {
+        if (typeof value === 'number' && Number.isFinite(value))
+            return value;
+        if (typeof value === 'string') {
+            const asNum = Number(value);
+            if (Number.isFinite(asNum) && asNum > 0)
+                return asNum;
+            const asDate = Date.parse(value);
+            if (Number.isFinite(asDate) && asDate > 0)
+                return asDate;
+        }
+        return 0;
+    }
+    getLatestGeneralMessageAt(messages, author) {
+        let lastAt = 0;
+        for (const m of messages) {
+            if ((m.from || '').toLowerCase() !== author)
+                continue;
+            if ((m.channel || 'general') !== 'general')
+                continue;
+            const ts = this.parseTimestamp(m.timestamp);
+            if (ts > lastAt)
+                lastAt = ts;
+        }
+        return lastAt;
+    }
+    /**
+     * Get the latest message timestamp from an agent across ALL channels.
+     * Used for activity suppression — if an agent is posting anywhere, they're not idle.
+     */
+    getLatestAnyMessageAt(messages, author) {
+        let lastAt = 0;
+        for (const m of messages) {
+            if ((m.from || '').toLowerCase() !== author)
+                continue;
+            const ts = this.parseTimestamp(m.timestamp);
+            if (ts > lastAt)
+                lastAt = ts;
+        }
+        return lastAt;
+    }
+    /**
+     * Returns true if the agent has posted a rate-limit / provider-failure message
+     * within the given window. Used to suppress false cadence alerts during outages.
+     *
+     * These messages look like: "⚠️ Agent failed before reply: All models failed..."
+     * They indicate the agent is alive and trying but blocked by infra — not genuinely idle.
+     */
+    hasRecentRateLimitFailure(messages, agent, now, windowMs) {
+        const cutoff = now - windowMs;
+        return messages.some((m) => {
+            if ((m.from || '').toLowerCase() !== agent)
+                return false;
+            const ts = Number(m.timestamp || 0);
+            if (ts < cutoff)
+                return false;
+            const content = typeof m.content === 'string' ? m.content : '';
+            return content.startsWith('⚠️ Agent failed before reply:') || content.startsWith('⚠️ API rate limit reached');
+        });
+    }
+    findLastValidStatusAt(messages, agent) {
+        let lastAt = null;
+        for (const m of messages) {
+            if ((m.from || '').toLowerCase() !== agent)
+                continue;
+            if ((m.channel || 'general') !== 'general')
+                continue;
+            const content = typeof m.content === 'string' ? m.content : '';
+            const hasTask = /\btask-[a-z0-9-]+\b/i.test(content);
+            const hasStrictTriplet = /1\)\s*(?:\*\*)?[^\n]*\bshipped\b/i.test(content)
+                && /2\)\s*(?:\*\*)?[^\n]*\bblocker\b/i.test(content)
+                && /3\)\s*(?:\*\*)?[^\n]*\bnext\b/i.test(content);
+            const hasLooseStatusSignals = (/\bshipped\b|\bartifact(?:s)?\b|\bcommit\b/i.test(content))
+                && /\bblocker\b/i.test(content)
+                && (/\bnext\b/i.test(content) || /\beta\b/i.test(content));
+            if (!hasTask || (!hasStrictTriplet && !hasLooseStatusSignals))
+                continue;
+            const ts = this.parseTimestamp(m.timestamp);
+            if (!ts)
+                continue;
+            if (!lastAt || ts > lastAt)
+                lastAt = ts;
+        }
+        return lastAt;
+    }
+    findLastTrioGeneralUpdate(messages) {
+        const trioSet = new Set(this.trioAgents);
+        let lastAt = 0;
+        for (const agent of trioSet) {
+            // Consider both #general and any-channel activity
+            const generalLast = this.getLatestGeneralMessageAt(messages, agent);
+            const anyLast = this.getLatestAnyMessageAt(messages, agent);
+            const agentLast = Math.max(generalLast, anyLast);
+            if (agentLast > lastAt)
+                lastAt = agentLast;
+        }
+        return lastAt || Date.now();
+    }
+    /** Check if agent posted a task comment recently (returns age in minutes or null) */
+    getTaskCommentAgeForAgent(taskId, agent, now) {
+        const comments = taskManager.getTaskComments(taskId);
+        if (!comments.length)
+            return null;
+        // Find most recent comment by this agent
+        let latestTs = 0;
+        for (const c of comments) {
+            if ((c.author || '').toLowerCase() !== agent)
+                continue;
+            const ts = this.parseTimestamp(c.timestamp);
+            if (ts > latestTs)
+                latestTs = ts;
+        }
+        if (!latestTs)
+            return null;
+        return Math.floor((now - latestTs) / 60_000);
+    }
+    /** Per-task focus window: agent started doing task recently → deep work window */
+    taskFocusWindows = new Map();
+    getTaskFocusWindow(taskId, agent, now) {
+        const key = `${agent}:${taskId}`;
+        const window = this.taskFocusWindows.get(key);
+        if (!window)
+            return null;
+        const elapsed = Math.floor((now - window.startedAt) / 60_000);
+        if (elapsed >= window.durationMin) {
+            this.taskFocusWindows.delete(key);
+            return null;
+        }
+        return { active: true, remainingMin: window.durationMin - elapsed };
+    }
+    /** Start a focus window for a task (called when agent moves task to doing) */
+    startTaskFocusWindow(agent, taskId, durationMin = 45) {
+        const key = `${agent}:${taskId}`;
+        this.taskFocusWindows.set(key, { agent, startedAt: Date.now(), durationMin });
+    }
+    /** Count recent status updates from agent on a task that mention ETA but no artifacts */
+    countRecentEtaOnlyUpdates(messages, agent, taskId) {
+        if (!taskId)
+            return 0;
+        let etaOnlyCount = 0;
+        const cutoff = Date.now() - (4 * 60 * 60 * 1000); // last 4 hours
+        for (const m of messages) {
+            if ((m.from || '').toLowerCase() !== agent)
+                continue;
+            const ts = this.parseTimestamp(m.timestamp);
+            if (!ts || ts < cutoff)
+                continue;
+            const content = typeof m.content === 'string' ? m.content : '';
+            if (!content.includes(taskId))
+                continue;
+            // Has ETA/time reference
+            const hasEta = /\beta\b|\b\d+\s*(?:min|m|h|hr|hour)/i.test(content);
+            if (!hasEta)
+                continue;
+            // Does NOT have artifact signal
+            const hasArtifact = /\b(shipped|artifact|commit|pr\s*#?\d+|pull request|merged|deployed|https?:\/\/github\.com)/i.test(content);
+            const hasBlocker = /\bblocker\b.*:.*\S/i.test(content) && !/\bblocker\b.*:\s*none\b/i.test(content);
+            if (!hasArtifact && !hasBlocker) {
+                etaOnlyCount++;
+            }
+        }
+        return etaOnlyCount;
+    }
+    findLastProductiveActionAt(messages, agent) {
+        let lastAt = null;
+        for (const m of messages) {
+            if ((m.from || '').toLowerCase() !== agent)
+                continue;
+            const content = typeof m.content === 'string' ? m.content : '';
+            if (!content)
+                continue;
+            // Productive shipping signal: artifact/commit/proof/merged/shipped references.
+            const hasProductiveSignal = /\b(shipped|shipped:|artifact|artifacts|commit|proof|merged|pr\s*#?\d+|pull request|deployed)\b/i.test(content);
+            if (!hasProductiveSignal)
+                continue;
+            const ts = this.parseTimestamp(m.timestamp);
+            if (!ts)
+                continue;
+            if (!lastAt || ts > lastAt)
+                lastAt = ts;
+        }
+        return lastAt;
+    }
+    hasStaleDoingTask(agent, tasks, now) {
+        const thresholdMs = this.idleNudgeActiveTaskMaxAgeMin * 60_000;
+        return tasks.some((task) => {
+            if ((task.assignee || '').toLowerCase() !== agent)
+                return false;
+            if (task.status !== 'doing')
+                return false;
+            const updatedAt = this.parseTimestamp(task.updatedAt) || this.parseTimestamp(task.createdAt);
+            const lastActivityAt = this.getTaskLastActivityAt(task.id, updatedAt);
+            if (!lastActivityAt)
+                return false;
+            return now - lastActivityAt > thresholdMs;
+        });
+    }
+    async getComplianceIncidents(now, messages) {
+        const fromWatchdog = await this.readWatchdogIncidents(now);
+        const inMemory = [];
+        const lastTrioGeneralUpdate = this.findLastTrioGeneralUpdate(messages);
+        const trioSilenceMin = Math.floor((now - lastTrioGeneralUpdate) / 1000 / 60);
+        if (trioSilenceMin > this.trioSilenceMaxMin) {
+            inMemory.push({
+                id: `inc-trio-${lastTrioGeneralUpdate}`,
+                agent: 'trio',
+                taskId: null,
+                type: 'trio-silence',
+                minutesOver: trioSilenceMin - this.trioSilenceMaxMin,
+                escalateTo: ['kai', 'link', 'pixel'],
+                openedAt: lastTrioGeneralUpdate + this.trioSilenceMaxMin * 60 * 1000,
+            });
+        }
+        return [...fromWatchdog, ...inMemory].sort((a, b) => b.openedAt - a.openedAt);
+    }
+    async readWatchdogIncidents(now) {
+        const paths = [
+            process.env.WATCHDOG_INCIDENT_LOG,
+            resolve(process.cwd(), '../workspace-link/openclaw-plugin-reflectt-node/incidents/watchdog-incidents.jsonl'),
+            resolve(process.cwd(), '../../workspace-link/openclaw-plugin-reflectt-node/incidents/watchdog-incidents.jsonl'),
+        ].filter((p) => Boolean(p));
+        for (const path of paths) {
+            try {
+                const raw = await readFile(path, 'utf8');
+                const lines = raw.trim().split('\n').filter(Boolean);
+                const recent = lines.slice(-100);
+                const incidents = recent
+                    .map((line) => {
+                    try {
+                        return JSON.parse(line);
+                    }
+                    catch {
+                        return null;
+                    }
+                })
+                    .filter((v) => v !== null)
+                    .map((entry, idx) => this.mapWatchdogIncident(entry, idx, now))
+                    .filter((v) => v !== null);
+                if (incidents.length > 0) {
+                    return incidents;
+                }
+            }
+            catch {
+                // try next path
+            }
+        }
+        return [];
+    }
+    /** Maximum reasonable incident age (7 days). Anything older is stale/impossible. */
+    static MAX_INCIDENT_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+    /**
+     * Clamp minutesOver to a reasonable bound and reject impossible durations.
+     * Returns null if the calculated age exceeds MAX_INCIDENT_AGE_MS (impossible/stale).
+     */
+    clampIncidentAge(now, reference, thresholdMin) {
+        if (reference <= 0 || reference > now)
+            return null; // invalid timestamp
+        const ageMs = now - reference;
+        if (ageMs > TeamHealthMonitor.MAX_INCIDENT_AGE_MS)
+            return null; // impossible duration
+        return Math.max(0, Math.floor(ageMs / 60_000) - thresholdMin);
+    }
+    /**
+     * Validate that a task referenced by an incident still exists and is in a
+     * monitored status. Returns false for deleted or closed/done/cancelled tasks.
+     */
+    isTaskStillActive(taskId) {
+        if (!taskId)
+            return true; // no task reference — allow (e.g. trio silence)
+        const task = taskManager.getTask(taskId);
+        if (!task)
+            return false; // deleted (hard DELETE)
+        const closedStatuses = new Set(['done', 'cancelled']);
+        return !closedStatuses.has(task.status);
+    }
+    mapWatchdogIncident(entry, idx, now) {
+        const openedAt = entry.at || now;
+        const taskId = entry.taskId ?? null;
+        const rawType = entry.type || '';
+        // Skip incidents for tasks that no longer exist (hard-deleted) or are closed
+        if (taskId && !this.isTaskStillActive(taskId))
+            return null;
+        if (rawType === 'trio_general_silence') {
+            const thresholdMin = Math.floor((entry.thresholdMs || this.trioSilenceMaxMin * 60_000) / 60_000);
+            const reference = entry.lastUpdateAt || openedAt;
+            const minutesOver = this.clampIncidentAge(now, reference, thresholdMin);
+            if (minutesOver === null)
+                return null; // impossible duration — skip
+            return {
+                id: `inc-watchdog-trio-${openedAt}-${idx}`,
+                agent: 'trio',
+                taskId,
+                type: 'trio-silence',
+                minutesOver,
+                escalateTo: ['kai', 'link', 'pixel'],
+                openedAt,
+            };
+        }
+        if (rawType === 'stale_working') {
+            const agent = entry.agent || 'unknown';
+            const thresholdMin = Math.floor((entry.thresholdMs || this.workerCadenceMaxMin * 60_000) / 60_000);
+            const reference = entry.lastUpdateAt || openedAt;
+            const minutesOver = this.clampIncidentAge(now, reference, thresholdMin);
+            if (minutesOver === null)
+                return null; // impossible duration — skip
+            return {
+                id: `inc-watchdog-stale-${agent}-${openedAt}-${idx}`,
+                agent,
+                taskId,
+                type: 'stale-working',
+                minutesOver,
+                escalateTo: agent === 'pixel' ? ['kai', 'link'] : ['kai', 'pixel'],
+                openedAt,
+            };
+        }
+        if (rawType === 'blocked_without_handoff') {
+            const agent = entry.agent || 'unknown';
+            const thresholdMin = Math.floor((entry.thresholdMs || this.blockedEscalationMin * 60_000) / 60_000);
+            const reference = entry.lastUpdateAt || entry.blockedSinceAt || openedAt;
+            const minutesOver = this.clampIncidentAge(now, reference, thresholdMin);
+            if (minutesOver === null)
+                return null; // impossible duration — skip
+            return {
+                id: `inc-watchdog-blocked-${agent}-${openedAt}-${idx}`,
+                agent,
+                taskId,
+                type: 'blocked-overdue',
+                minutesOver,
+                escalateTo: agent === 'pixel' ? ['kai', 'link'] : ['kai', 'pixel'],
+                openedAt,
+            };
+        }
+        return null;
+    }
+    getLatestTaskCommentAgeMin(taskId, now) {
+        if (!taskId)
+            return null;
+        const comments = taskManager.getTaskComments(taskId);
+        if (!comments.length)
+            return null;
+        const latestTs = comments.reduce((max, c) => Math.max(max, this.parseTimestamp(c.timestamp)), 0);
+        if (!latestTs)
+            return null;
+        return Math.max(0, Math.floor((now - latestTs) / 60_000));
+    }
+    getLatestMentionAgeMin(messages, agent, now) {
+        const needle = `@${agent.toLowerCase()}`;
+        let latest = 0;
+        for (const m of messages) {
+            const from = (m?.from || '').toLowerCase();
+            if (!from || from === agent.toLowerCase())
+                continue;
+            const content = typeof m?.content === 'string' ? m.content.toLowerCase() : '';
+            if (!content.includes(needle))
+                continue;
+            const ts = this.parseTimestamp(m.timestamp);
+            if (ts > latest)
+                latest = ts;
+        }
+        if (!latest)
+            return null;
+        return Math.max(0, Math.floor((now - latest) / 60_000));
+    }
+    buildSuggestedAction(args) {
+        if (args.hasRecentBlocker || args.status === 'blocked') {
+            return 'Post blocker owner + unblock ETA in #general and request reviewer help if blocked >20m.';
+        }
+        if (args.idleWithActiveTask) {
+            return 'Post shipped/blocker/next+ETA now and either move task to validating with artifact or set blocked reason.';
+        }
+        if (args.status === 'silent' || args.status === 'offline') {
+            return 'Acknowledge in #general and confirm active lane status or set task to blocked/todo if paused.';
+        }
+        if (!args.hasTask && (args.status === 'idle' || args.status === 'active')) {
+            return 'Claim next backlog task or post explicit no-work state; avoid idle-without-lane drift.';
+        }
+        return 'Post a concrete next artifact ETA and keep task status aligned with actual execution state.';
+    }
+    /**
+     * Get health status for all agents
+     */
+    async getAgentHealthStatuses(now) {
+        const presences = presenceManager.getAllPresence();
+        const tasks = taskManager.listTasks({});
+        const messages = chatManager.getMessages({ limit: 300 });
+        const agentStatuses = [];
+        // Get unique agent list from all sources
+        const agentSet = new Set();
+        presences.forEach((p) => agentSet.add(p.agent));
+        tasks.forEach((t) => t.assignee && agentSet.add(t.assignee));
+        messages.forEach((m) => agentSet.add(m.from));
+        for (const agent of agentSet) {
+            const presence = presences.find((p) => p.agent === agent);
+            const agentTasks = tasks
+                .filter((t) => t.assignee === agent && t.status === 'doing')
+                .sort((a, b) => {
+                const aTs = Number(a.updatedAt || a.createdAt || 0);
+                const bTs = Number(b.updatedAt || b.createdAt || 0);
+                return bTs - aTs;
+            });
+            const agentMessages = messages.filter((m) => m.from === agent);
+            const lastSeen = presence?.lastUpdate || 0;
+            const minutesSinceLastSeen = Math.floor((now - lastSeen) / 1000 / 60);
+            // Count messages in last 24h
+            const oneDayAgo = now - (24 * 60 * 60 * 1000);
+            const messageCount24h = agentMessages.filter((m) => m.timestamp > oneDayAgo).length;
+            const lastProductiveAt = this.findLastProductiveActionAt(messages, agent);
+            const minutesSinceProductive = lastProductiveAt
+                ? Math.floor((now - lastProductiveAt) / 1000 / 60)
+                : null;
+            // Determine status
+            let status = 'offline';
+            if (minutesSinceLastSeen < 15) {
+                status = 'active';
+            }
+            else if (minutesSinceLastSeen < 45) {
+                status = 'idle';
+            }
+            else if (minutesSinceLastSeen < 120) {
+                status = 'silent'; // >45min = >3 heartbeats
+            }
+            // Check for blockers in recent messages
+            const recentBlockers = this.findBlockersInMessages(agentMessages.slice(-10));
+            // Override status if explicitly blocked
+            if (presence?.status === 'blocked' || recentBlockers.length > 0) {
+                status = 'blocked';
+            }
+            const activeTask = agentTasks[0];
+            const hasActiveTask = Boolean(activeTask);
+            const idleWithActiveTask = hasActiveTask && minutesSinceLastSeen > 60;
+            const mentionAgeMin = this.getLatestMentionAgeMin(messages, agent, now);
+            const lastTransition = activeTask?.metadata?.last_transition;
+            const lastTransitionTs = this.parseTimestamp(lastTransition?.timestamp);
+            const isFlagged = status === 'blocked' || status === 'silent' || status === 'offline' || idleWithActiveTask;
+            const actionable_reason = isFlagged
+                ? {
+                    task_id: activeTask?.id || null,
+                    last_task_comment_age_min: this.getLatestTaskCommentAgeMin(activeTask?.id, now),
+                    last_transition: {
+                        type: typeof lastTransition?.type === 'string' ? lastTransition.type : null,
+                        actor: typeof lastTransition?.actor === 'string' ? lastTransition.actor : null,
+                        age_min: lastTransitionTs ? Math.max(0, Math.floor((now - lastTransitionTs) / 60_000)) : null,
+                    },
+                    last_mention_age_min: mentionAgeMin,
+                    suggested_action: this.buildSuggestedAction({
+                        status,
+                        idleWithActiveTask,
+                        hasRecentBlocker: recentBlockers.length > 0,
+                        hasTask: hasActiveTask,
+                    }),
+                }
+                : null;
+            agentStatuses.push({
+                agent,
+                status,
+                lastSeen,
+                minutesSinceLastSeen,
+                currentTask: activeTask?.title,
+                activeTaskId: activeTask?.id,
+                activeTaskTitle: activeTask?.title,
+                activeTaskPrLink: this.extractTaskPrLink(activeTask),
+                recentBlockers,
+                messageCount24h,
+                lastProductiveAt,
+                minutesSinceProductive,
+                idleWithActiveTask,
+                actionable_reason,
+            });
+        }
+        return agentStatuses.sort((a, b) => b.lastSeen - a.lastSeen);
+    }
+    /**
+     * Extract blocker mentions from recent messages
+     */
+    async extractBlockers() {
+        const messages = chatManager.getMessages({ limit: 200 });
+        const blockerMap = new Map();
+        for (const msg of messages) {
+            const blockers = this.findBlockersInMessages([msg]);
+            for (const blocker of blockers) {
+                const key = `${msg.from}:${blocker}`;
+                if (blockerMap.has(key)) {
+                    const existing = blockerMap.get(key);
+                    existing.mentionCount++;
+                    existing.lastMentioned = msg.timestamp;
+                }
+                else {
+                    blockerMap.set(key, {
+                        agent: msg.from,
+                        blocker,
+                        mentionCount: 1,
+                        firstMentioned: msg.timestamp,
+                        lastMentioned: msg.timestamp,
+                    });
+                }
+            }
+        }
+        return Array.from(blockerMap.values())
+            .filter(b => b.mentionCount >= 2) // Only blockers mentioned multiple times
+            .sort((a, b) => b.lastMentioned - a.lastMentioned);
+    }
+    /**
+     * Find blocker keywords in messages (improved with false-positive reduction)
+     */
+    findBlockersInMessages(messages) {
+        const blockers = [];
+        for (const msg of messages) {
+            const from = (msg?.from || '').toLowerCase();
+            if (from === 'system' || from === 'watchdog') {
+                continue;
+            }
+            const rawContent = typeof msg?.content === 'string' ? msg.content : '';
+            if (!rawContent)
+                continue;
+            const content = rawContent.toLowerCase();
+            // Skip known non-actionable watchdog/template/fallback chatter.
+            const looksLikeStatusTemplate = /1\)\s*shipped:\s*</i.test(rawContent) ||
+                /2\)\s*blocker:\s*</i.test(rawContent) ||
+                /3\)\s*next:\s*</i.test(rawContent);
+            if (content.includes('post shipped / blocker / next+eta now') ||
+                content.includes('system watchdog') ||
+                content.includes('system fallback') ||
+                content.includes('idle nudge') ||
+                content.includes('required status now') ||
+                content.includes('system reminder: you appear idle') ||
+                content.includes('system escalation:') ||
+                looksLikeStatusTemplate) {
+                continue;
+            }
+            // Skip status reports and completed work mentions
+            if (content.includes('was blocked') ||
+                content.includes('unblocked') ||
+                content.includes('fixed') ||
+                content.includes('resolved') ||
+                content.includes('completed') ||
+                content.includes('done')) {
+                continue;
+            }
+            for (const keyword of this.blockerKeywords) {
+                if (content.includes(keyword)) {
+                    // Additional context check: must be near agent name or "I" to be real blocker
+                    const hasContext = content.includes(' i ') ||
+                        content.includes('i\'m') ||
+                        content.includes('we\'re') ||
+                        content.match(/@\w+/);
+                    if (!hasContext)
+                        continue;
+                    // Extract context around the keyword
+                    const index = content.indexOf(keyword);
+                    const start = Math.max(0, index - 20);
+                    const end = Math.min(content.length, index + keyword.length + 40);
+                    const context = rawContent.substring(start, end).trim();
+                    blockers.push(context);
+                    break; // Only one blocker per message
+                }
+            }
+        }
+        return blockers;
+    }
+    hasScopeSplitSignal(taskId) {
+        const comments = taskManager.getTaskComments(taskId);
+        const splitSignals = [
+            'deconflict',
+            'scope split',
+            'owner map',
+            'no overlap',
+            'non-overlap',
+            'boundary',
+            'aligned',
+            'split ownership',
+            'avoid duplicate',
+        ];
+        return comments.some(comment => {
+            const content = comment.content.toLowerCase();
+            return splitSignals.some(signal => content.includes(signal));
+        });
+    }
+    /**
+     * Detect overlapping work (agents working on similar things)
+     */
+    async detectOverlaps() {
+        const tasks = taskManager
+            .listTasks({ status: 'doing' })
+            .filter(task => Boolean(task.assignee));
+        if (tasks.length < 2)
+            return [];
+        const taskKeywords = new Map();
+        for (const task of tasks) {
+            const keywords = this.extractKeywords(`${task.title} ${task.description || ''}`);
+            taskKeywords.set(task.id, new Set(keywords));
+        }
+        const overlapTopics = new Map();
+        for (let i = 0; i < tasks.length; i += 1) {
+            for (let j = i + 1; j < tasks.length; j += 1) {
+                const a = tasks[i];
+                const b = tasks[j];
+                if (!a.assignee || !b.assignee)
+                    continue;
+                if (a.assignee === b.assignee)
+                    continue;
+                // If either task explicitly carries deconfliction/scope-split notes,
+                // treat this pair as resolved and suppress recurring overlap alerts.
+                if (this.hasScopeSplitSignal(a.id) || this.hasScopeSplitSignal(b.id)) {
+                    continue;
+                }
+                const aKeywords = taskKeywords.get(a.id) || new Set();
+                const bKeywords = taskKeywords.get(b.id) || new Set();
+                const shared = Array.from(aKeywords).filter(k => bKeywords.has(k));
+                // Require 2+ shared keywords to avoid generic single-word collisions.
+                if (shared.length < 2)
+                    continue;
+                const topic = shared.slice(0, 2).join('+');
+                if (!overlapTopics.has(topic)) {
+                    overlapTopics.set(topic, new Set());
+                }
+                overlapTopics.get(topic).add(a.assignee);
+                overlapTopics.get(topic).add(b.assignee);
+            }
+        }
+        const overlaps = [];
+        for (const [topic, agentsSet] of overlapTopics.entries()) {
+            const agents = Array.from(agentsSet);
+            if (agents.length < 2)
+                continue;
+            overlaps.push({
+                agents,
+                topic,
+                confidence: agents.length >= 3 ? 'high' : 'medium',
+            });
+        }
+        return overlaps;
+    }
+    /**
+     * Extract keywords from text
+     */
+    extractKeywords(text) {
+        const stopWords = new Set([
+            'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by',
+            // Domain-generic terms that cause overlap false positives.
+            'task', 'tasks', 'reflectt', 'node', 'agent', 'agents', 'lane', 'lanes', 'work', 'status',
+        ]);
+        return text
+            .toLowerCase()
+            .split(/\W+/)
+            .filter(word => word.length > 3 && !stopWords.has(word))
+            .slice(0, 8);
+    }
+    shouldEmitCadenceAlert(key, now, cooldownMin) {
+        const lastAt = this.cadenceAlertState.get(key);
+        if (!lastAt)
+            return true;
+        const cooldown = Number(cooldownMin ?? this.cadenceAlertCooldownMin);
+        const cooldownMs = cooldown * 60_000;
+        return now - lastAt >= cooldownMs;
+    }
+    markCadenceAlert(key, now) {
+        this.cadenceAlertState.set(key, now);
+    }
+    /**
+     * Enhanced suppression: check if agent has had ANY recent activity
+     * (task comment, status update, chat message, task transition) since
+     * the last alert for this key. If so, suppress the repeat.
+     */
+    hasRecentActivitySinceLastAlert(agent, key, now) {
+        const lastAlertAt = this.cadenceAlertState.get(key);
+        if (!lastAlertAt)
+            return false; // No prior alert → can't suppress based on activity
+        const messages = chatManager.getMessages({ limit: 200 });
+        // Check for any message from this agent after the last alert
+        const hasRecentMessage = messages.some((m) => {
+            const from = (m.from || '').toLowerCase();
+            const ts = Number(m.timestamp || 0);
+            return from === agent && ts > lastAlertAt;
+        });
+        if (hasRecentMessage)
+            return true;
+        // Check for task comments from this agent after last alert
+        const tasks = taskManager.listTasks({ status: 'doing' });
+        for (const task of tasks) {
+            if ((task.assignee || '').toLowerCase() !== agent)
+                continue;
+            const comments = taskManager.getTaskComments?.(task.id) || [];
+            const hasRecentComment = comments.some((c) => {
+                const author = (c.author || '').toLowerCase();
+                const ts = Number(c.createdAt || 0);
+                return author === agent && ts > lastAlertAt;
+            });
+            if (hasRecentComment)
+                return true;
+        }
+        // Check for task status changes after last alert
+        const updatedTask = tasks.find((t) => {
+            const assignee = (t.assignee || '').toLowerCase();
+            const updatedAt = Number(t.updatedAt || 0);
+            return assignee === agent && updatedAt > lastAlertAt;
+        });
+        if (updatedTask)
+            return true;
+        return false;
+    }
+    async logWatchdogIncident(entry) {
+        const path = process.env.WATCHDOG_INCIDENT_LOG
+            || resolve(process.cwd(), 'incidents/watchdog-incidents.jsonl');
+        await mkdir(dirname(path), { recursive: true });
+        await appendFile(path, `${JSON.stringify(entry)}\n`, 'utf8');
+    }
+    resolveIdleNudgeLane(agent, presenceTaskRaw, tasks, now) {
+        return resolveIdleNudgeLane(agent, presenceTaskRaw, tasks, now, this.idleNudgeActiveTaskMaxAgeMin);
+    }
+    async runCadenceWatchdogTick(now = Date.now(), options) {
+        const dryRun = options?.dryRun === true;
+        const alerts = [];
+        // Persist tick time so /health/system can prove this watchdog is actually firing.
+        recordSystemLoopTick('cadence_watchdog', now);
+        // Source of truth: unified policy config (file + env overlays).
+        // Fallback: legacy env-based flags.
+        const cadenceCfg = policyManager.get().cadenceWatchdog;
+        const cadenceEnabled = cadenceCfg?.enabled ?? this.cadenceWatchdogEnabled;
+        const silenceMin = Number(cadenceCfg?.silenceMin ?? this.cadenceSilenceMin);
+        const workingStaleMin = Number(cadenceCfg?.workingStaleMin ?? this.cadenceWorkingStaleMin);
+        const workingTaskMaxAgeMin = Number(cadenceCfg?.workingTaskMaxAgeMin ?? this.cadenceWorkingTaskMaxAgeMin);
+        const alertCooldownMin = Number(cadenceCfg?.alertCooldownMin ?? this.cadenceAlertCooldownMin);
+        if (!cadenceEnabled) {
+            return { alerts };
+        }
+        // Startup grace period — suppress alerts for first N minutes after service restart.
+        // Prevents a fresh restart from immediately firing a batch of stale alerts for all agents.
+        if (now - this.systemStartTime < this.cadenceStartupGraceMs) {
+            return { alerts };
+        }
+        const tasks = taskManager.listTasks({});
+        const messages = chatManager.getMessages({ limit: 300 });
+        const lastTrioGeneralUpdate = this.findLastTrioGeneralUpdate(messages);
+        const trioSilenceMin = Math.floor((now - lastTrioGeneralUpdate) / 60_000);
+        if (trioSilenceMin >= silenceMin) {
+            const key = 'trio_general_silence';
+            if (this.shouldEmitCadenceAlert(key, now, alertCooldownMin)) {
+                // Enhanced suppression: skip if any trio member has had activity since last alert
+                const anyTrioActive = this.trioAgents.some(a => this.hasRecentActivitySinceLastAlert(a, key, now));
+                if (anyTrioActive) {
+                    // Activity detected — extend cooldown without re-alerting
+                    this.markCadenceAlert(key, now);
+                }
+                else if (this.trioAgents.some(a => this.hasRecentRateLimitFailure(messages, a, now, this.cadenceRateLimitSuppressMs))) {
+                    // Rate-limit failure suppressor: trio is silent due to provider outage, not genuine inactivity
+                    this.markCadenceAlert(key, now);
+                }
+                else {
+                    const content = `🔁 **[Product Enforcement] Cadence reset**: no #general update from trio for ${trioSilenceMin}m (threshold ${silenceMin}m). @kai @link @pixel post status now: 1) shipped 2) blocker 3) next+ETA. *(Automated — no leadership action needed.)*`;
+                    alerts.push(content);
+                    if (!dryRun) {
+                        await routeMessage({ from: 'system', content, category: 'escalation', severity: 'warning', mentions: ['kai', 'link', 'pixel'] });
+                        await this.logWatchdogIncident({
+                            type: 'trio_general_silence',
+                            at: now,
+                            thresholdMs: silenceMin * 60_000,
+                            lastUpdateAt: lastTrioGeneralUpdate,
+                        });
+                        this.markCadenceAlert(key, now);
+                    }
+                }
+            }
+        }
+        const trioSet = new Set(this.trioAgents);
+        const doingByAgent = new Map();
+        for (const task of tasks) {
+            if (!task.assignee)
+                continue;
+            // Only monitor actively-doing tasks; skip done/cancelled/blocked
+            if (task.status !== 'doing')
+                continue;
+            const agent = (task.assignee || '').toLowerCase();
+            if (!trioSet.has(agent))
+                continue;
+            const taskTs = Number(task.updatedAt || task.createdAt || 0);
+            const taskAgeMin = taskTs > 0 ? Math.floor((now - taskTs) / 60_000) : Number.MAX_SAFE_INTEGER;
+            if (taskAgeMin > workingTaskMaxAgeMin) {
+                continue;
+            }
+            const current = doingByAgent.get(agent);
+            const currentTs = current ? Number(current.updatedAt || current.createdAt || 0) : 0;
+            if (!current || taskTs >= currentTs) {
+                doingByAgent.set(agent, task);
+            }
+        }
+        const workingTasks = Array.from(doingByAgent.values());
+        for (const task of workingTasks) {
+            const agent = (task.assignee || '').toLowerCase();
+            // Re-check task status at nudge time (guards against race between list and nudge)
+            // Also handles deleted tasks: if getTask returns null, the task was hard-deleted
+            const freshTask = taskManager.getTask(task.id);
+            if (!freshTask)
+                continue; // task was deleted — skip alert
+            if (freshTask.status !== 'doing')
+                continue; // task moved to done/cancelled/blocked — skip
+            const lastGeneralAt = this.getLatestGeneralMessageAt(messages, agent);
+            const lastAnyAt = this.getLatestAnyMessageAt(messages, agent);
+            // Use the more recent of #general or any-channel activity
+            const lastAt = Math.max(lastGeneralAt, lastAnyAt);
+            const rawStaleMin = lastAt > 0 ? Math.floor((now - lastAt) / 60_000) : 9999;
+            // Cap at MAX_INCIDENT_AGE to prevent impossible durations (e.g. from stale cache)
+            const maxStaleMin = Math.floor(TeamHealthMonitor.MAX_INCIDENT_AGE_MS / 60_000);
+            const staleMin = Math.min(rawStaleMin, maxStaleMin);
+            if (staleMin < workingStaleMin)
+                continue;
+            // Also check task comments as activity signal
+            const taskCommentAge = this.getTaskCommentAgeForAgent(task.id, agent, now);
+            if (taskCommentAge !== null && taskCommentAge < workingStaleMin)
+                continue;
+            const key = `stale_working:${agent}:${task.id}`;
+            if (!this.shouldEmitCadenceAlert(key, now, alertCooldownMin))
+                continue;
+            // Enhanced suppression: skip if agent has had ANY activity since last alert
+            if (this.hasRecentActivitySinceLastAlert(agent, key, now)) {
+                this.markCadenceAlert(key, now);
+                continue;
+            }
+            // Also suppress first-time alerts if agent posted ANY #general message recently
+            const agentLastGeneralAt = this.getLatestGeneralMessageAt(messages, agent);
+            if (agentLastGeneralAt > 0) {
+                const sinceGeneralMin = Math.floor((now - agentLastGeneralAt) / 60_000);
+                if (sinceGeneralMin < workingStaleMin)
+                    continue;
+            }
+            // Rate-limit failure suppressor: if the agent's silence is caused by infra failures
+            // (rate limits, provider outage), suppress the alert and extend cooldown silently.
+            // Prevents noisy false positives during provider outages when agents are trying but blocked.
+            if (this.hasRecentRateLimitFailure(messages, agent, now, this.cadenceRateLimitSuppressMs)) {
+                this.markCadenceAlert(key, now);
+                continue;
+            }
+            const content = `@${agent} [Product Enforcement] status=working with no update for ${staleMin}m on ${task.id}. Post status now: 1) shipped 2) blocker 3) next+ETA. *(Automated — no leadership action needed.)*`;
+            alerts.push(content);
+            if (!dryRun) {
+                await routeMessage({ from: 'system', content, category: 'watchdog-alert', severity: 'info', taskId: task.id, mentions: [agent, 'kai', 'pixel'] });
+                await this.logWatchdogIncident({
+                    type: 'stale_working',
+                    at: now,
+                    agent,
+                    taskId: task.id,
+                    thresholdMs: workingStaleMin * 60_000,
+                    lastUpdateAt: lastAt || null,
+                    workingSinceAt: task.updatedAt || task.createdAt || null,
+                });
+                this.markCadenceAlert(key, now);
+            }
+        }
+        return { alerts };
+    }
+    /**
+     * Ensure the mention_rescue_state SQLite table exists.
+     * Called lazily on first tick to avoid import-time side effects.
+     */
+    ensureMentionRescueDb() {
+        if (this.mentionRescueDbInitialized)
+            return;
+        try {
+            const db = getDb();
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS mention_rescue_state (
+          thread_key TEXT PRIMARY KEY,
+          message_ids TEXT NOT NULL DEFAULT '[]',
+          rescued_at INTEGER NOT NULL,
+          rescue_count INTEGER NOT NULL DEFAULT 1
+        )
+      `);
+            this.mentionRescueDbInitialized = true;
+        }
+        catch {
+            // DB not available — fall back to in-memory only
+        }
+    }
+    /**
+     * Extract which trio agents were actually mentioned in a message.
+     * Returns lowercase agent ids (subset of this.trioAgents).
+     */
+    extractMentionedTrioAgents(content) {
+        if (!content)
+            return [];
+        const matches = content.match(/@(kai|link|pixel)\b/gi) || [];
+        const uniq = new Set();
+        for (const m of matches) {
+            const name = m.replace('@', '').toLowerCase();
+            if (this.trioAgents.includes(name))
+                uniq.add(name);
+        }
+        return Array.from(uniq);
+    }
+    /**
+     * Build a thread-level idempotency key for mention-rescue.
+     * Groups mentions by thread context so that multiple messages in the same
+     * thread/channel with the same mentioned agents produce one rescue, not many.
+     *
+     * Key format: `{channel}:{threadId || 'root'}:{sortedAgents}`
+     */
+    buildMentionThreadKey(mention) {
+        const channel = String(mention.channel || 'general');
+        const threadId = String(mention.threadId || mention.thread_id || 'root');
+        const content = typeof mention.content === 'string' ? mention.content : '';
+        const agents = this.extractMentionedTrioAgents(content)
+            .slice()
+            .sort()
+            .join(',');
+        return `${channel}:${threadId}:${agents}`;
+    }
+    /**
+     * Check if a thread key has already been rescued (persisted or in-memory).
+     */
+    isThreadRescued(threadKey, cooldownMs, now) {
+        // Check in-memory first (covers current session)
+        for (const [, entry] of this.mentionRescueState) {
+            if (entry.rescueCount > 0) {
+                // In-memory entries are keyed by mentionId, not threadKey — checked below
+            }
+        }
+        // Check SQLite for cross-restart persistence
+        try {
+            this.ensureMentionRescueDb();
+            const db = getDb();
+            const row = db.prepare('SELECT rescued_at, rescue_count FROM mention_rescue_state WHERE thread_key = ?').get(threadKey);
+            if (row && row.rescue_count > 0) {
+                // Within cooldown window — still suppressed
+                if (now - row.rescued_at < cooldownMs)
+                    return true;
+                // Beyond cooldown — allow re-rescue (but this is unusual; max age usually prevents it)
+                return true; // One-shot per thread: once rescued, always rescued
+            }
+        }
+        catch {
+            // DB read failed — rely on in-memory only
+        }
+        return false;
+    }
+    /**
+     * Record a thread rescue in both in-memory state and SQLite.
+     */
+    recordThreadRescue(threadKey, mentionId, now) {
+        // In-memory
+        this.mentionRescueState.set(mentionId, { lastRescueAt: now, rescueCount: 1 });
+        this.mentionRescueLastAt = now;
+        // SQLite persistence
+        try {
+            this.ensureMentionRescueDb();
+            const db = getDb();
+            const existing = db.prepare('SELECT message_ids, rescue_count FROM mention_rescue_state WHERE thread_key = ?').get(threadKey);
+            if (existing) {
+                const ids = JSON.parse(existing.message_ids || '[]');
+                if (!ids.includes(mentionId))
+                    ids.push(mentionId);
+                db.prepare('UPDATE mention_rescue_state SET message_ids = ?, rescued_at = ?, rescue_count = rescue_count + 1 WHERE thread_key = ?').run(JSON.stringify(ids), now, threadKey);
+            }
+            else {
+                db.prepare('INSERT INTO mention_rescue_state (thread_key, message_ids, rescued_at, rescue_count) VALUES (?, ?, ?, 1)').run(threadKey, JSON.stringify([mentionId]), now);
+            }
+        }
+        catch {
+            // DB write failed — in-memory state still covers current session
+        }
+    }
+    /**
+     * Prune stale rescue state entries from both in-memory and SQLite.
+     */
+    pruneRescueState(now) {
+        const pruneThresholdMs = 60 * 60_000;
+        // Prune in-memory
+        for (const [key, entry] of this.mentionRescueState) {
+            if (now - entry.lastRescueAt > pruneThresholdMs) {
+                this.mentionRescueState.delete(key);
+            }
+        }
+        // Prune SQLite
+        try {
+            this.ensureMentionRescueDb();
+            const db = getDb();
+            db.prepare('DELETE FROM mention_rescue_state WHERE rescued_at < ?').run(now - pruneThresholdMs);
+        }
+        catch {
+            // DB prune failed — non-critical
+        }
+    }
+    async runMentionRescueTick(now = Date.now(), options) {
+        const dryRun = options?.dryRun === true;
+        const rescued = [];
+        // Persist tick time so /health/system can prove this watchdog is actually firing.
+        recordSystemLoopTick('mention_rescue', now);
+        const policy = policyManager.get();
+        const cfg = policy.mentionRescue;
+        if (!cfg?.enabled) {
+            return { rescued };
+        }
+        // Initialize DB table on first tick
+        this.ensureMentionRescueDb();
+        const messages = chatManager.getMessages({ limit: 300 });
+        const mentions = messages.filter((m) => {
+            const from = (m.from || '').toLowerCase();
+            const channel = (m.channel || 'general');
+            const content = typeof m.content === 'string' ? m.content : '';
+            if (channel !== 'general' || from !== 'ryan')
+                return false;
+            return /@(kai|link|pixel)\b/i.test(content);
+        });
+        const trioSet = new Set(this.trioAgents);
+        // Guardrails: never allow instant mention-rescue (creates #general spam).
+        const delayMin = Math.max(3, Number(cfg.delayMin || 0));
+        const cooldownMin = Math.max(1, Number(cfg.cooldownMin || 0));
+        const globalCooldownMin = Math.max(1, Number(cfg.globalCooldownMin || 0));
+        const delayMs = delayMin * 60_000;
+        const cooldownMs = cooldownMin * 60_000;
+        const globalCooldownMs = globalCooldownMin * 60_000;
+        // Maximum age for mentions to be eligible for rescue (30 minutes).
+        // Prevents stale mentions from hours/days ago from triggering infinite rescue loops.
+        const maxMentionAgeMs = 30 * 60_000;
+        // Track which thread keys we've already processed this tick to avoid
+        // emitting multiple rescues for different messages in the same thread.
+        const processedThreadKeys = new Set();
+        for (const mention of mentions) {
+            const mentionId = String(mention.id || mention.timestamp || '');
+            if (!mentionId)
+                continue;
+            const mentionAt = Number(mention.timestamp || 0);
+            if (!mentionAt || now - mentionAt < delayMs)
+                continue;
+            // Skip stale mentions — if a mention is older than maxMentionAgeMs, stop rescuing it.
+            // This prevents infinite rescue loops for old unresolved mentions.
+            if (now - mentionAt > maxMentionAgeMs)
+                continue;
+            // Global cooldown to avoid duplicate fallback nudges across near-identical mentions.
+            if (now - this.mentionRescueLastAt < globalCooldownMs)
+                continue;
+            const mentionContent = typeof mention.content === 'string' ? mention.content : '';
+            const mentionedAgents = this.extractMentionedTrioAgents(mentionContent);
+            if (mentionedAgents.length === 0)
+                continue;
+            // ── Thread-level idempotency ─────────────────────────────────────
+            // Build a thread key that groups mentions by channel + thread + mentioned agents.
+            // This prevents duplicate rescues when Ryan sends multiple messages in the
+            // same thread mentioning the same agents.
+            const threadKey = this.buildMentionThreadKey(mention);
+            // Skip if we already processed this thread key during this tick
+            if (processedThreadKeys.has(threadKey))
+                continue;
+            // Skip if this thread was already rescued (persisted across restarts)
+            if (this.isThreadRescued(threadKey, cooldownMs, now)) {
+                processedThreadKeys.add(threadKey);
+                continue;
+            }
+            // Also check in-memory per-message state (backward compat)
+            const rescueEntry = this.mentionRescueState.get(mentionId);
+            if (rescueEntry && rescueEntry.rescueCount > 0)
+                continue;
+            // Cancel mention-rescue only when the trio reply is in the same channel and
+            // (when applicable) the same thread context as the original mention.
+            //
+            // Without this scoping, any trio chatter anywhere after the mention timestamp
+            // can incorrectly suppress the rescue.
+            const mentionChannel = String(mention.channel || 'general');
+            const mentionThreadId = ((typeof mention.threadId === 'string' ? mention.threadId : null) ||
+                (typeof mention.thread_id === 'string' ? mention.thread_id : null) ||
+                null);
+            const replied = messages.some((m) => {
+                const from = (m.from || '').toLowerCase();
+                if (!trioSet.has(from))
+                    return false;
+                const ts = Number(m.timestamp || 0);
+                if (!(ts > mentionAt))
+                    return false;
+                const channel = String(m.channel || 'general');
+                if (channel !== mentionChannel)
+                    return false;
+                const threadId = (typeof m.threadId === 'string' ? m.threadId : null) ||
+                    (typeof m.thread_id === 'string' ? m.thread_id : null) ||
+                    null;
+                // If the mention itself is inside a thread, only count replies inside that same thread.
+                if (mentionThreadId)
+                    return threadId === mentionThreadId;
+                // Root mention: count either a root reply (no thread) or a reply in the thread
+                // directly attached to the mention (threadId === mentionId).
+                if (threadId)
+                    return threadId === mentionId;
+                return true;
+            });
+            if (replied) {
+                processedThreadKeys.add(threadKey);
+                continue;
+            }
+            // Focus mode is a hard suppressor for fallback nudges.
+            const anyFocused = mentionedAgents.some(a => presenceManager.isInFocus(a) !== null);
+            if (anyFocused)
+                continue;
+            const mentionList = mentionedAgents.map(a => `@${a}`).join(' ');
+            const content = `[[reply_to:${mentionId}]] system fallback: mention received. ${mentionList} are being nudged to respond.`;
+            rescued.push(content);
+            if (!dryRun) {
+                await routeMessage({
+                    from: 'system',
+                    content,
+                    category: 'mention-rescue',
+                    severity: 'warning',
+                    mentions: mentionedAgents,
+                    // Keep the fallback in the same channel as the original mention.
+                    forceChannel: String(mention.channel || 'general'),
+                });
+                this.recordThreadRescue(threadKey, mentionId, now);
+            }
+            processedThreadKeys.add(threadKey);
+        }
+        // Prune stale state from both in-memory and SQLite
+        this.pruneRescueState(now);
+        return { rescued };
+    }
+    async runIdleNudgeTick(now = Date.now(), options) {
+        const dryRun = options?.dryRun === true;
+        const nudged = [];
+        const decisions = [];
+        // Persist tick time so /health/system can prove this watchdog is actually firing.
+        recordSystemLoopTick('idle_nudge', now);
+        const presences = presenceManager.getAllPresence();
+        const tasks = taskManager.listTasks({});
+        const taskById = new Map(tasks.map((t) => [t.id, t]));
+        const messages = chatManager.getMessages({ limit: 300 });
+        for (const presence of presences) {
+            const agent = (presence.agent || '').toLowerCase();
+            if (!agent)
+                continue;
+            const lastActiveAt = presence.last_active || presence.lastUpdate || 0;
+            const inactivityMin = lastActiveAt ? Math.floor((now - lastActiveAt) / 60_000) : 0;
+            const tier = inactivityMin >= this.idleNudgeEscalateMin ? 2 : 1;
+            const lane = this.resolveIdleNudgeLane(agent, presence.task, tasks, now);
+            const taskId = lane.selectedTaskId;
+            const baseDecision = {
+                agent,
+                taskId,
+                idleMinutes: inactivityMin,
+                warnMin: this.idleNudgeWarnMin,
+                escalateMin: this.idleNudgeEscalateMin,
+                cooldownMin: this.idleNudgeCooldownMin,
+                recentSuppressMin: this.idleNudgeSuppressRecentMin,
+                lane,
+                at: now,
+            };
+            if (!this.idleNudgeEnabled) {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'disabled', renderedMessage: null });
+                continue;
+            }
+            if (this.idleNudgeExcluded.has(agent)) {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'excluded', renderedMessage: null });
+                continue;
+            }
+            // Respect focus mode — suppress idle nudges for focused agents
+            const focusState = presenceManager.isInFocus(agent);
+            if (focusState) {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'focus-mode-active', renderedMessage: null });
+                continue;
+            }
+            if (presence.status === 'offline') {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'offline', renderedMessage: null });
+                continue;
+            }
+            // Queue-clear (no doing/blocked/validating task) is eligible for engagement nudges — see no-active-lane handler below.
+            if (presence.status === 'blocked') {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'blocked-task-suppressed', renderedMessage: null });
+                continue;
+            }
+            if (!lastActiveAt) {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'no-last-active', renderedMessage: null });
+                continue;
+            }
+            const hasStaleDoingTask = this.hasStaleDoingTask(agent, tasks, now);
+            const lastProductiveActionAt = this.findLastProductiveActionAt(messages, agent);
+            if (!hasStaleDoingTask && lastProductiveActionAt) {
+                const sinceShipMin = Math.floor((now - lastProductiveActionAt) / 60_000);
+                if (sinceShipMin < this.idleNudgeShipCooldownMin) {
+                    decisions.push({ ...baseDecision, decision: 'none', reason: 'recent-shipped-cooldown', renderedMessage: null });
+                    continue;
+                }
+            }
+            // Task-comment activity suppression: treat task comments as not-idle
+            if (taskId) {
+                const taskCommentAge = this.getTaskCommentAgeForAgent(taskId, agent, now);
+                if (taskCommentAge !== null && taskCommentAge < 30) {
+                    decisions.push({ ...baseDecision, decision: 'none', reason: 'recent-task-comment', renderedMessage: null });
+                    continue;
+                }
+            }
+            // Per-task focus window: 45-60m deep work suppression
+            if (taskId) {
+                const focusWindow = this.getTaskFocusWindow(taskId, agent, now);
+                if (focusWindow && focusWindow.active) {
+                    decisions.push({ ...baseDecision, decision: 'none', reason: 'task-focus-window', renderedMessage: null });
+                    continue;
+                }
+            }
+            if (inactivityMin < this.idleNudgeWarnMin) {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'below-warn-threshold', renderedMessage: null });
+                continue;
+            }
+            // Suppress if agent posted ANY message recently (any channel, not just #general)
+            const lastAnyMsgAt = this.getLatestAnyMessageAt(messages, agent);
+            if (lastAnyMsgAt) {
+                const sinceLastMsgMin = Math.floor((now - lastAnyMsgAt) / 60_000);
+                if (sinceLastMsgMin < this.idleNudgeSuppressRecentMin) {
+                    decisions.push({ ...baseDecision, decision: 'none', reason: 'recent-activity-suppressed', renderedMessage: null });
+                    continue;
+                }
+            }
+            const lastValidStatusAt = this.findLastValidStatusAt(messages, agent);
+            if (lastValidStatusAt) {
+                const sinceLastStatusMin = Math.floor((now - lastValidStatusAt) / 60_000);
+                if (sinceLastStatusMin < this.idleNudgeSuppressRecentMin) {
+                    decisions.push({ ...baseDecision, decision: 'none', reason: 'recent-activity-suppressed', renderedMessage: null });
+                    continue;
+                }
+            }
+            const state = this.idleNudgeState.get(agent);
+            if (state) {
+                const sinceNudgeMin = Math.floor((now - state.lastNudgeAt) / 60_000);
+                if (sinceNudgeMin < this.idleNudgeCooldownMin) {
+                    decisions.push({ ...baseDecision, decision: 'none', reason: 'cooldown-active', renderedMessage: null });
+                    continue;
+                }
+            }
+            const hasValidatingTask = tasks.some((t) => (t.assignee || '').toLowerCase() === agent && t.status === 'validating');
+            if (hasValidatingTask) {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'validating-task-suppressed', renderedMessage: null });
+                continue;
+            }
+            // Engagement nudge: if agent is idle and has no active doing lane, prompt them to pull/claim work.
+            if (lane.laneReason === 'no-active-lane') {
+                const signature = `queue-clear:${agent}`;
+                if (state && state.lastSignature === signature && state.unchangedNudgeCount >= 2) {
+                    decisions.push({ ...baseDecision, decision: 'none', reason: 'max-repeat-reached', renderedMessage: null });
+                    continue;
+                }
+                const intro = tier === 1
+                    ? `@${agent} system reminder: you appear idle for ${inactivityMin}m and have no active task. Pull work now.`
+                    : `@${agent} @kai system escalation: ${inactivityMin}m idle and no active task. Pull work now.`;
+                const template = [
+                    `1) Pull: GET /tasks/next?agent=${agent}`,
+                    `2) Claim: PATCH /tasks/<id> { "status": "doing", "assignee": "${agent}" }`,
+                    '3) Post: /tasks/<id>/comments with 1) shipped 2) blocker 3) next+ETA',
+                ].join('\n');
+                const renderedMessage = `${intro}\n${template}`;
+                decisions.push({
+                    ...baseDecision,
+                    decision: tier === 1 ? 'warn' : 'escalate',
+                    reason: 'queue-clear',
+                    renderedMessage,
+                });
+                if (dryRun) {
+                    continue;
+                }
+                await routeMessage({
+                    from: 'system',
+                    content: renderedMessage,
+                    category: 'watchdog-alert',
+                    severity: tier === 2 ? 'warning' : 'info',
+                    mentions: tier === 2 ? [agent, 'kai'] : [agent],
+                });
+                const unchangedNudgeCount = state && state.lastSignature === signature
+                    ? state.unchangedNudgeCount + 1
+                    : 1;
+                this.idleNudgeState.set(agent, {
+                    lastNudgeAt: now,
+                    lastTier: tier,
+                    lastSignature: signature,
+                    unchangedNudgeCount,
+                });
+                nudged.push(agent);
+                continue;
+            }
+            if (lane.laneReason === 'stale-lane') {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'stale-active-task', renderedMessage: null });
+                continue;
+            }
+            if (lane.laneReason === 'ambiguous-lane') {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'ambiguous-active-task', renderedMessage: null });
+                continue;
+            }
+            if (lane.laneReason === 'presence-task-mismatch') {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'presence-task-mismatch', renderedMessage: null });
+                continue;
+            }
+            // Safety guard: never emit when an active task is missing/invalid.
+            if (!taskId || !/^task-[a-z0-9-]+$/i.test(taskId)) {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'missing-active-task', renderedMessage: null });
+                continue;
+            }
+            const selectedTask = taskById.get(taskId);
+            if (selectedTask?.status === 'blocked') {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'blocked-task-suppressed', renderedMessage: null });
+                continue;
+            }
+            if (selectedTask && selectedTask.status !== 'doing') {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'done-task-suppressed', renderedMessage: null });
+                continue;
+            }
+            const signature = `${taskId}:${selectedTask?.status || 'unknown'}:${selectedTask?.updatedAt || 0}`;
+            if (state && state.lastSignature === signature && state.unchangedNudgeCount >= 2) {
+                decisions.push({ ...baseDecision, decision: 'none', reason: 'max-repeat-reached', renderedMessage: null });
+                continue;
+            }
+            // ETA-only escalation: after 2 repeated status updates without artifacts,
+            // require artifact link or explicit blocker, else flag for reassignment
+            const etaOnlyCount = this.countRecentEtaOnlyUpdates(messages, agent, taskId);
+            const needsArtifact = etaOnlyCount >= 2;
+            const intro = needsArtifact
+                ? `@${agent} @kai escalation: ${etaOnlyCount} status updates on ${taskId} with no artifact or blocker. Post artifact link or explicit blocker now, or task will be flagged for reassignment.`
+                : tier === 1
+                    ? `@${agent} system reminder: you appear idle for ${inactivityMin}m. Post a quick status update now.`
+                    : `@${agent} @kai system escalation: ${inactivityMin}m idle. Post required status format now.`;
+            const template = needsArtifact
+                ? [
+                    `Task: ${taskId}`,
+                    '1) Artifact: <PR link, commit, or file path> (REQUIRED)',
+                    '2) Blocker: <explicit blocker if no artifact>',
+                ].join('\n')
+                : [
+                    `Task: ${taskId}`,
+                    '1) Shipped: <artifact/commit/file>',
+                    '2) Blocker: <none or explicit blocker>',
+                    '3) Next: <next deliverable + ETA>',
+                ].join('\n');
+            const renderedMessage = `${intro}\n${template}`;
+            decisions.push({
+                ...baseDecision,
+                decision: tier === 1 ? 'warn' : 'escalate',
+                reason: 'eligible',
+                renderedMessage,
+            });
+            if (dryRun) {
+                continue;
+            }
+            await routeMessage({
+                from: 'system',
+                content: renderedMessage,
+                category: 'watchdog-alert',
+                severity: tier === 2 ? 'warning' : 'info',
+                taskId: taskId || undefined,
+                mentions: tier === 2 ? [agent, 'kai'] : [agent],
+            });
+            const unchangedNudgeCount = state && state.lastSignature === signature
+                ? state.unchangedNudgeCount + 1
+                : 1;
+            this.idleNudgeState.set(agent, {
+                lastNudgeAt: now,
+                lastTier: tier,
+                lastSignature: signature,
+                unchangedNudgeCount,
+            });
+            nudged.push(agent);
+        }
+        this.idleNudgeLastDecisions = decisions;
+        return { nudged, decisions };
+    }
+    getIdleNudgeDebug() {
+        const decisionCounts = { none: 0, warn: 0, escalate: 0 };
+        const reasonCounts = {};
+        const laneReasonCounts = {};
+        for (const decision of this.idleNudgeLastDecisions) {
+            decisionCounts[decision.decision] += 1;
+            reasonCounts[decision.reason] = (reasonCounts[decision.reason] || 0) + 1;
+            laneReasonCounts[decision.lane.laneReason] = (laneReasonCounts[decision.lane.laneReason] || 0) + 1;
+        }
+        return {
+            config: {
+                enabled: this.idleNudgeEnabled,
+                warnMin: this.idleNudgeWarnMin,
+                escalateMin: this.idleNudgeEscalateMin,
+                cooldownMin: this.idleNudgeCooldownMin,
+                recentSuppressMin: this.idleNudgeSuppressRecentMin,
+                shipCooldownMin: this.idleNudgeShipCooldownMin,
+                activeTaskMaxAgeMin: this.idleNudgeActiveTaskMaxAgeMin,
+                excluded: Array.from(this.idleNudgeExcluded.values()).sort(),
+            },
+            state: Array.from(this.idleNudgeState.entries()).map(([agent, s]) => ({
+                agent,
+                lastNudgeAt: s.lastNudgeAt,
+                lastTier: s.lastTier,
+                lastSignature: s.lastSignature,
+                unchangedNudgeCount: s.unchangedNudgeCount,
+            })),
+            summary: {
+                decisionCounts,
+                reasonCounts,
+                laneReasonCounts,
+            },
+            lastDecisions: this.idleNudgeLastDecisions,
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Get simple summary for quick display
+     */
+    async getSummary() {
+        const health = await this.getHealth();
+        const lines = [
+            `🏥 **Team Health** (${new Date(health.timestamp).toLocaleTimeString()})`,
+            '',
+            `**Active:** ${health.activeAgents.join(', ') || 'none'}`,
+            `**Silent >45min:** ${health.silentAgents.join(', ') || 'none'}`,
+        ];
+        if (health.blockers.length > 0) {
+            lines.push('');
+            lines.push('**🚫 Blockers:**');
+            health.blockers.slice(0, 3).forEach(b => {
+                lines.push(`- ${b.agent}: ${b.blocker} (${b.mentionCount}x)`);
+            });
+        }
+        if (health.overlaps.length > 0) {
+            lines.push('');
+            lines.push('**⚠️ Overlapping work:**');
+            health.overlaps.slice(0, 3).forEach(o => {
+                lines.push(`- ${o.agents.join(', ')}: ${o.topic}`);
+            });
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Record health snapshot for history tracking
+     */
+    async recordSnapshot() {
+        const now = Date.now();
+        // Only snapshot once per hour
+        if (now - this.lastSnapshotTime < this.SNAPSHOT_INTERVAL_MS) {
+            return;
+        }
+        const health = await this.getHealth();
+        this.healthHistory.push(health);
+        this.lastSnapshotTime = now;
+        // Trim old history
+        if (this.healthHistory.length > this.MAX_HISTORY) {
+            this.healthHistory = this.healthHistory.slice(-this.MAX_HISTORY);
+        }
+    }
+    /**
+     * Get health history for trends
+     */
+    getHealthHistory(days = 7) {
+        const cutoff = Date.now() - (days * 24 * 60 * 60 * 1000);
+        return this.healthHistory.filter(h => h.timestamp >= cutoff);
+    }
+    /**
+     * Track request for system health monitoring
+     */
+    trackRequest(duration) {
+        this.requestCount++;
+        this.requestTimes.push(duration);
+        // Keep only recent request times
+        if (this.requestTimes.length > this.MAX_REQUEST_TIMES) {
+            this.requestTimes = this.requestTimes.slice(-this.MAX_REQUEST_TIMES);
+        }
+    }
+    /**
+     * Track error for system health monitoring
+     */
+    trackError() {
+        this.errorCount++;
+    }
+    /**
+     * Get system health metrics
+     */
+    getSystemHealth() {
+        const uptime = Date.now() - this.systemStartTime;
+        const uptimeHours = Math.floor(uptime / 1000 / 60 / 60);
+        // Calculate response time percentiles
+        const sorted = this.requestTimes.slice().sort((a, b) => a - b);
+        const avgResponseTime = sorted.length > 0
+            ? sorted.reduce((a, b) => a + b, 0) / sorted.length
+            : 0;
+        const p95Index = Math.floor(sorted.length * 0.95);
+        const p95ResponseTime = sorted[p95Index] || 0;
+        const errorRate = this.requestCount > 0
+            ? this.errorCount / this.requestCount
+            : 0;
+        return {
+            uptime,
+            uptimeHours,
+            memory: process.memoryUsage(),
+            requestCount: this.requestCount,
+            errorCount: this.errorCount,
+            avgResponseTime: Math.round(avgResponseTime),
+            p95ResponseTime: Math.round(p95ResponseTime),
+            errorRate: Math.round(errorRate * 10000) / 100, // percentage
+        };
+    }
+}
+export const healthMonitor = new TeamHealthMonitor();
+//# sourceMappingURL=health.js.map