@aiassesstech/mighty-mark 0.5.7 → 0.5.9

package/dist/checks/fleet-transport.js

@@ -0,0 +1,759 @@
+/**
+ * Fleet-bus transport health checks — 8 checks in the 'fleet' category.
+ *
+ * These checks validate Layers 1-2 of the fleet-bus stack (Gateway + Transport),
+ * complementing the existing checks in fleet-health.ts that cover Layer 3 (Bus Logic).
+ *
+ * Audit-based (filesystem reads only, no gateway access needed):
+ *   #40  fleet-transport-delivery     At least 1 outcome=delivered/success in 24h
+ *   #41  fleet-transport-error-rate   Error rate < 30% (24h), trend < 10% (7d)
+ *   #40a fleet-agent:{name}           Per-agent delivery status (one check per agent)
+ *
+ * Config/version (filesystem reads, optional shell exec):
+ *   #42 fleet-config-validation      No config warnings in logs + no legacy symlinks
+ *   #43 fleet-gateway-version-compat Installed OpenClaw ≥ fleet-bus openclaw.minVersion
+ *   #44 fleet-global-package-version Global fleet-bus version ≥ expected minimum
+ *   #45 fleet-callgateway-resolution gateway/call.js exists at expected paths
+ *   #46 fleet-acp-dispatch-status    ACP dispatch explicitly disabled
+ *
+ * Live (opt-in, requires gateway process):
+ *   #47 fleet-live-ping              Self-ping via transportSend, verify delivery
+ *
+ * Spec: SPEC-FLEET-BUS-HEALTH-CHECK-BATTERY-1.1
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { exec, now, resolveOpenClawHome, getConfigPath } from './check-context.js';
+const EXPECTED_AGENTS = ['grillo', 'jessie', 'noah', 'nole', 'mighty-mark', 'sam'];
+const DEFAULT_ERROR_RATE_WARN = 0.1;
+const DEFAULT_ERROR_RATE_FAIL = 0.3;
+function getFleetBusDir(ctx) {
+    return ctx?.fleetBusDir ?? path.join(resolveOpenClawHome(), 'workspace', 'fleet-bus');
+}
+function readAuditEventsByAgent(auditDir) {
+    const byAgent = new Map();
+    for (const agent of EXPECTED_AGENTS) {
+        const jsonlPath = path.join(auditDir, `${agent}.audit.jsonl`);
+        if (!fs.existsSync(jsonlPath))
+            continue;
+        try {
+            const content = fs.readFileSync(jsonlPath, 'utf-8').trim();
+            if (!content)
+                continue;
+            const events = [];
+            for (const line of content.split('\n')) {
+                if (!line.trim())
+                    continue;
+                try {
+                    events.push(JSON.parse(line));
+                }
+                catch {
+                    // skip malformed lines
+                }
+            }
+            if (events.length > 0) {
+                byAgent.set(agent, events);
+            }
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    return byAgent;
+}
+function readAuditEvents(auditDir) {
+    const all = [];
+    for (const events of readAuditEventsByAgent(auditDir).values()) {
+        all.push(...events);
+    }
+    return all;
+}
+function isSuccessOutcome(event) {
+    return event.outcome === 'delivered' || event.outcome === 'success';
+}
+function filterByAge(events, maxAgeMs) {
+    const cutoff = Date.now() - maxAgeMs;
+    return events.filter((e) => {
+        if (!e.timestamp)
+            return false;
+        return new Date(e.timestamp).getTime() >= cutoff;
+    });
+}
+// ── #40 Fleet Transport Delivery ────────────────────────────────
+/**
+ * #40 — At least one message delivered in the last 24 hours.
+ *
+ * Accepts both `outcome=delivered` (current) and `outcome=success`
+ * (future guaranteed-delivery). See BB Amendment #1.
+ */
+export async function checkFleetTransportDelivery(ctx) {
+    const start = Date.now();
+    const auditDir = path.join(getFleetBusDir(ctx), 'audit');
+    if (!fs.existsSync(auditDir)) {
+        return {
+            name: 'Fleet transport delivery',
+            category: 'fleet',
+            status: 'warn',
+            message: 'No audit directory — bus has never sent a message',
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    const allEvents = readAuditEvents(auditDir);
+    const recent = filterByAge(allEvents, 24 * 60 * 60 * 1000);
+    if (recent.length === 0) {
+        return {
+            name: 'Fleet transport delivery',
+            category: 'fleet',
+            status: 'warn',
+            message: 'No fleet messages in last 24h (bus idle)',
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    const delivered = recent.filter(isSuccessOutcome).length;
+    if (delivered === 0) {
+        return {
+            name: 'Fleet transport delivery',
+            category: 'fleet',
+            status: 'fail',
+            message: `0 delivered / ${recent.length} total — 100% failure rate (transport broken)`,
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    return {
+        name: 'Fleet transport delivery',
+        category: 'fleet',
+        status: 'pass',
+        message: `${delivered} delivered / ${recent.length} total in last 24h`,
+        timestamp: now(),
+        durationMs: Date.now() - start,
+    };
+}
+// ── #41 Fleet Transport Error Rate ──────────────────────────────
+/**
+ * #41 — Monitor error rate with dual-window approach.
+ *
+ * Primary window (24h) for FAIL threshold, secondary (7d) for trend WARN.
+ * Thresholds: 10% WARN / 30% FAIL (BB Amendment #4 & #7).
+ */
+export async function checkFleetTransportErrorRate(ctx) {
+    const start = Date.now();
+    const auditDir = path.join(getFleetBusDir(ctx), 'audit');
+    const warnThreshold = ctx?.fleetErrorRateWarn ?? DEFAULT_ERROR_RATE_WARN;
+    const failThreshold = ctx?.fleetErrorRateFail ?? DEFAULT_ERROR_RATE_FAIL;
+    if (!fs.existsSync(auditDir)) {
+        return {
+            name: 'Fleet transport error rate',
+            category: 'fleet',
+            status: 'pass',
+            message: 'No audit trail — no errors to report',
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    const allEvents = readAuditEvents(auditDir);
+    const events24h = filterByAge(allEvents, 24 * 60 * 60 * 1000);
+    const events7d = filterByAge(allEvents, 7 * 24 * 60 * 60 * 1000);
+    if (events24h.length === 0 && events7d.length === 0) {
+        return {
+            name: 'Fleet transport error rate',
+            category: 'fleet',
+            status: 'pass',
+            message: 'No audit events in last 7 days',
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    if (events24h.length > 0) {
+        const errors24h = events24h.filter((e) => e.outcome === 'error').length;
+        const rate24h = errors24h / events24h.length;
+        if (rate24h >= failThreshold) {
+            return {
+                name: 'Fleet transport error rate',
+                category: 'fleet',
+                status: 'fail',
+                message: `Error rate ${pct(rate24h)} (${errors24h}/${events24h.length} events failed, 24h) — transport broken`,
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            };
+        }
+        if (rate24h >= warnThreshold) {
+            return {
+                name: 'Fleet transport error rate',
+                category: 'fleet',
+                status: 'warn',
+                message: `Error rate ${pct(rate24h)} (${errors24h}/${events24h.length} events failed, 24h) — investigate transport`,
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            };
+        }
+    }
+    if (events7d.length > 0) {
+        const errors7d = events7d.filter((e) => e.outcome === 'error').length;
+        const rate7d = errors7d / events7d.length;
+        if (rate7d >= warnThreshold) {
+            return {
+                name: 'Fleet transport error rate',
+                category: 'fleet',
+                status: 'warn',
+                message: `24h clean but 7d trend: ${pct(rate7d)} (${errors7d}/${events7d.length} events) — intermittent failures`,
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            };
+        }
+    }
+    const count = events24h.length > 0 ? events24h.length : events7d.length;
+    const delivered = events24h.length > 0
+        ? events24h.filter(isSuccessOutcome).length
+        : events7d.filter(isSuccessOutcome).length;
+    return {
+        name: 'Fleet transport error rate',
+        category: 'fleet',
+        status: 'pass',
+        message: `Error rate 0% — ${delivered}/${count} events delivered (${events24h.length > 0 ? '24h' : '7d'})`,
+        timestamp: now(),
+        durationMs: Date.now() - start,
+    };
+}
+// ── #40a Per-Agent Transport Delivery ───────────────────────────
+/**
+ * #40a — Per-agent delivery status (one result per agent).
+ *
+ * Returns one CheckResult per agent that has an audit file.
+ * Agents with 0 deliveries and >0 events get FAIL; agents with
+ * no events get WARN (idle); agents with at least 1 delivery get PASS.
+ */
+export async function checkPerAgentDelivery(ctx) {
+    const start = Date.now();
+    const auditDir = path.join(getFleetBusDir(ctx), 'audit');
+    const results = [];
+    if (!fs.existsSync(auditDir)) {
+        return results;
+    }
+    const byAgent = readAuditEventsByAgent(auditDir);
+    for (const agent of EXPECTED_AGENTS) {
+        const agentEvents = byAgent.get(agent);
+        if (!agentEvents || agentEvents.length === 0) {
+            results.push({
+                name: `Fleet agent: ${agent}`,
+                category: 'fleet',
+                status: 'warn',
+                message: 'No audit events (idle)',
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            });
+            continue;
+        }
+        const recent = filterByAge(agentEvents, 24 * 60 * 60 * 1000);
+        if (recent.length === 0) {
+            results.push({
+                name: `Fleet agent: ${agent}`,
+                category: 'fleet',
+                status: 'warn',
+                message: `${agentEvents.length} total events, none in last 24h`,
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            });
+            continue;
+        }
+        const delivered = recent.filter(isSuccessOutcome).length;
+        const errors = recent.filter((e) => e.outcome === 'error').length;
+        if (delivered === 0 && errors > 0) {
+            results.push({
+                name: `Fleet agent: ${agent}`,
+                category: 'fleet',
+                status: 'fail',
+                message: `0/${recent.length} delivered (24h) — transport broken for ${agent}`,
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            });
+            continue;
+        }
+        const rate = recent.length > 0 ? errors / recent.length : 0;
+        const warnThreshold = ctx?.fleetErrorRateWarn ?? DEFAULT_ERROR_RATE_WARN;
+        if (rate >= warnThreshold) {
+            results.push({
+                name: `Fleet agent: ${agent}`,
+                category: 'fleet',
+                status: 'warn',
+                message: `${delivered}/${recent.length} delivered, ${pct(rate)} error rate (24h)`,
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            });
+            continue;
+        }
+        results.push({
+            name: `Fleet agent: ${agent}`,
+            category: 'fleet',
+            status: 'pass',
+            message: `${delivered}/${recent.length} delivered (24h)`,
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        });
+    }
+    return results;
+}
+// ── #42 Fleet Config & Symlink Validation ───────────────────────
+/**
+ * #42 — Detect config validation warnings + legacy symlinks.
+ *
+ * Tiered log source: health endpoint → log file → journalctl fallback.
+ * Also detects the clawdbot.json symlink (BB Amendment #2 & #8).
+ */
+export async function checkFleetConfigValidation(ctx) {
+    const start = Date.now();
+    const issues = [];
+    // Sub-check 1: Config validation warnings in gateway logs
+    let logContent = '';
+    try {
+        const logPaths = [
+            '/var/log/openclaw/gateway.log',
+            path.join(resolveOpenClawHome(), 'logs', 'gateway.log'),
+        ];
+        for (const logPath of logPaths) {
+            if (fs.existsSync(logPath)) {
+                logContent = fs.readFileSync(logPath, 'utf-8');
+                break;
+            }
+        }
+        if (!logContent) {
+            logContent = exec('journalctl -u openclaw-gateway --no-pager --since "1 hour ago" 2>/dev/null || echo ""', ctx);
+        }
+    }
+    catch {
+        // No log source available — not a failure, just can't check
+    }
+    if (logContent) {
+        const invalidConfigMatches = logContent.match(/Invalid config at|Unrecognized key/gi);
+        if (invalidConfigMatches && invalidConfigMatches.length > 0) {
+            issues.push(`${invalidConfigMatches.length} config validation warning(s) — callGateway may fail`);
+        }
+    }
+    // Sub-check 2: Legacy symlink detection (BB Amendment #8)
+    const symlinkPaths = [
+        '/root/.clawdbot/clawdbot.json',
+        path.join(process.env.HOME || '', '.clawdbot', 'clawdbot.json'),
+    ];
+    for (const symlinkPath of symlinkPaths) {
+        try {
+            if (fs.existsSync(symlinkPath) && fs.lstatSync(symlinkPath).isSymbolicLink()) {
+                issues.push(`Legacy symlink ${symlinkPath} detected — remove and set OPENCLAW_HOME`);
+                break;
+            }
+        }
+        catch {
+            // Path doesn't exist or isn't accessible
+        }
+    }
+    if (issues.length > 0) {
+        return {
+            name: 'Fleet config validation',
+            category: 'fleet',
+            status: 'warn',
+            message: issues.join('; '),
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    return {
+        name: 'Fleet config validation',
+        category: 'fleet',
+        status: 'pass',
+        message: 'No config warnings; no legacy symlinks',
+        timestamp: now(),
+        durationMs: Date.now() - start,
+    };
+}
+// ── #43 Fleet Gateway Version Compatibility ─────────────────────
+/**
+ * #43 — Verify OpenClaw version meets fleet-bus minimum.
+ *
+ * Reads `openclaw.minVersion` from fleet-bus's package.json (BB Amendment #3).
+ */
+export async function checkFleetGatewayVersionCompat(ctx) {
+    const start = Date.now();
+    let installedVersion = 'unknown';
+    try {
+        const raw = exec('openclaw --version 2>/dev/null || echo "unknown"', ctx);
+        const match = raw.match(/(\d{4}\.\d+\.\d+)/);
+        installedVersion = match ? match[1] : raw.trim();
+    }
+    catch {
+        return {
+            name: 'Fleet gateway version compat',
+            category: 'fleet',
+            status: 'warn',
+            message: 'Could not determine OpenClaw version',
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    const packageJsonPath = ctx?.fleetBusPackageJsonPath ?? findFleetBusPackageJson();
+    if (!packageJsonPath) {
+        return {
+            name: 'Fleet gateway version compat',
+            category: 'fleet',
+            status: 'warn',
+            message: 'fleet-bus package.json not found — cannot verify compatibility',
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    try {
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        const minVersion = pkg?.openclaw?.minVersion;
+        if (!minVersion) {
+            return {
+                name: 'Fleet gateway version compat',
+                category: 'fleet',
+                status: 'warn',
+                message: `fleet-bus ${pkg.version ?? '?'} missing openclaw.minVersion — cannot verify compatibility`,
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            };
+        }
+        if (installedVersion === 'unknown') {
+            return {
+                name: 'Fleet gateway version compat',
+                category: 'fleet',
+                status: 'warn',
+                message: `Requires OpenClaw ≥ ${minVersion} but could not determine installed version`,
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            };
+        }
+        if (compareVersions(installedVersion, minVersion) < 0) {
+            return {
+                name: 'Fleet gateway version compat',
+                category: 'fleet',
+                status: 'fail',
+                message: `fleet-bus ${pkg.version} requires OpenClaw ≥ ${minVersion} but found ${installedVersion} — upgrade OpenClaw`,
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            };
+        }
+        return {
+            name: 'Fleet gateway version compat',
+            category: 'fleet',
+            status: 'pass',
+            message: `fleet-bus ${pkg.version} requires ≥ ${minVersion}, found ${installedVersion} — compatible`,
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    catch {
+        return {
+            name: 'Fleet gateway version compat',
+            category: 'fleet',
+            status: 'warn',
+            message: 'Could not read fleet-bus package.json',
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+}
+// ── #44 Fleet Global Package Version ────────────────────────────
+/**
+ * #44 — Verify globally installed fleet-bus is at expected minimum.
+ */
+export async function checkFleetGlobalPackageVersion(ctx) {
+    const start = Date.now();
+    const packageJsonPath = ctx?.fleetBusGlobalPackageJsonPath ?? findFleetBusPackageJson();
+    if (!packageJsonPath) {
+        return {
+            name: 'Fleet global package version',
+            category: 'fleet',
+            status: 'warn',
+            message: 'fleet-bus not found at global install path',
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    try {
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        const version = pkg.version;
+        const minVersion = pkg?.openclaw?.minVersion;
+        const expectedMin = '0.1.8';
+        if (compareVersions(version, expectedMin) < 0) {
+            return {
+                name: 'Fleet global package version',
+                category: 'fleet',
+                status: 'warn',
+                message: `Global fleet-bus ${version} — run: cd /root && npm install @aiassesstech/fleet-bus@latest`,
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            };
+        }
+        return {
+            name: 'Fleet global package version',
+            category: 'fleet',
+            status: 'pass',
+            message: `Global fleet-bus ${version}${minVersion ? ` (requires OpenClaw ≥ ${minVersion})` : ''}`,
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    catch {
+        return {
+            name: 'Fleet global package version',
+            category: 'fleet',
+            status: 'warn',
+            message: 'Could not read fleet-bus package.json',
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+}
+// ── #45 Fleet callGateway Resolution ────────────────────────────
+/**
+ * #45 — Verify that gateway/call.js exists at known paths.
+ *
+ * This check runs in CLI mode (file existence) since the full resolution
+ * strategy requires the gateway process context.
+ */
+export async function checkFleetCallGatewayResolution(ctx) {
+    const start = Date.now();
+    const searchPaths = [
+        '/usr/lib/node_modules/openclaw/dist/gateway/call.js',
+        '/usr/local/lib/node_modules/openclaw/dist/gateway/call.js',
+        path.join(process.env.HOME || '', 'node_modules', 'openclaw', 'dist', 'gateway', 'call.js'),
+        path.join(process.env.HOME || '', '.openclaw', 'node_modules', 'openclaw', 'dist', 'gateway', 'call.js'),
+    ];
+    for (const searchPath of searchPaths) {
+        if (fs.existsSync(searchPath)) {
+            return {
+                name: 'Fleet callGateway resolution',
+                category: 'fleet',
+                status: 'pass',
+                message: `gateway/call.js found at ${searchPath}`,
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            };
+        }
+    }
+    try {
+        const npmRoot = exec('npm root -g 2>/dev/null', ctx).trim();
+        const npmPath = path.join(npmRoot, 'openclaw', 'dist', 'gateway', 'call.js');
+        if (fs.existsSync(npmPath)) {
+            return {
+                name: 'Fleet callGateway resolution',
+                category: 'fleet',
+                status: 'pass',
+                message: `gateway/call.js found at ${npmPath}`,
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            };
+        }
+    }
+    catch {
+        // npm root failed
+    }
+    return {
+        name: 'Fleet callGateway resolution',
+        category: 'fleet',
+        status: 'fail',
+        message: 'gateway/call.js not found — fleet-bus transport will be disabled',
+        timestamp: now(),
+        durationMs: Date.now() - start,
+    };
+}
+// ── #46 Fleet ACP Dispatch Status ───────────────────────────────
+/**
+ * #46 — Verify ACP dispatch is explicitly disabled.
+ */
+export async function checkFleetAcpDispatchStatus(ctx) {
+    const start = Date.now();
+    const configPath = getConfigPath(ctx);
+    if (!fs.existsSync(configPath)) {
+        return {
+            name: 'Fleet ACP dispatch',
+            category: 'fleet',
+            status: 'warn',
+            message: `Config not found: ${configPath} — cannot verify ACP dispatch`,
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        const dispatchEnabled = config?.acp?.dispatch?.enabled;
+        if (dispatchEnabled === false) {
+            return {
+                name: 'Fleet ACP dispatch',
+                category: 'fleet',
+                status: 'pass',
+                message: 'ACP dispatch disabled',
+                timestamp: now(),
+                durationMs: Date.now() - start,
+            };
+        }
+        return {
+            name: 'Fleet ACP dispatch',
+            category: 'fleet',
+            status: 'warn',
+            message: `ACP dispatch ${dispatchEnabled === true ? 'enabled' : 'not set'} — add acp.dispatch.enabled=false to openclaw.json`,
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    catch {
+        return {
+            name: 'Fleet ACP dispatch',
+            category: 'fleet',
+            status: 'warn',
+            message: 'Could not parse config — cannot verify ACP dispatch',
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+}
+// ── #47 Fleet Live Ping (Opt-In) ────────────────────────────────
+/**
+ * #47 — Send a real fleet/ping through the transport stack.
+ *
+ * Prefers self-ping (loopback); falls back to agent with most recent lastSeen.
+ * Only runs when ctx.fleetLivePing is true (BB Answer Q1).
+ */
+export async function checkFleetLivePing(ctx) {
+    const start = Date.now();
+    // This check requires fleet-bus to be importable
+    let fb;
+    try {
+        fb = await import('@aiassesstech/fleet-bus');
+    }
+    catch {
+        return {
+            name: 'Fleet live ping',
+            category: 'fleet',
+            status: 'warn',
+            message: 'fleet-bus not installed — cannot perform live ping',
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    const { createFleetMessage, transportSend } = fb;
+    if (!transportSend) {
+        return {
+            name: 'Fleet live ping',
+            category: 'fleet',
+            status: 'warn',
+            message: 'transportSend not available — gateway context required',
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    const target = selectPingTarget(ctx);
+    try {
+        const msg = createFleetMessage('mighty-mark', target, 'fleet/ping', { probe: true });
+        const pingStart = Date.now();
+        await transportSend(msg);
+        const latency = Date.now() - pingStart;
+        return {
+            name: 'Fleet live ping',
+            category: 'fleet',
+            status: 'pass',
+            message: target === 'mighty-mark'
+                ? `fleet/ping self-loopback delivered in ${latency}ms`
+                : `fleet/ping delivered to ${target} in ${latency}ms`,
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        return {
+            name: 'Fleet live ping',
+            category: 'fleet',
+            status: 'fail',
+            message: `fleet/ping failed: ${detail}`,
+            timestamp: now(),
+            durationMs: Date.now() - start,
+        };
+    }
+}
+/**
+ * Select the best ping target (BB Amendment #5).
+ * Prefers self-ping. Falls back to agent with most recent lastSeen.
+ */
+function selectPingTarget(ctx) {
+    const cardsDir = path.join(getFleetBusDir(ctx), 'cards');
+    if (!fs.existsSync(cardsDir))
+        return 'mighty-mark';
+    let mostRecent = 'mighty-mark';
+    let mostRecentTime = 0;
+    for (const agent of EXPECTED_AGENTS) {
+        if (agent === 'mighty-mark')
+            continue;
+        const cardPath = path.join(cardsDir, `${agent}.json`);
+        try {
+            if (!fs.existsSync(cardPath))
+                continue;
+            const card = JSON.parse(fs.readFileSync(cardPath, 'utf-8'));
+            const lastSeen = new Date(card.lastSeen ?? card.registeredAt).getTime();
+            if (lastSeen > mostRecentTime) {
+                mostRecentTime = lastSeen;
+                mostRecent = agent;
+            }
+        }
+        catch {
+            // skip unreadable cards
+        }
+    }
+    return mostRecent;
+}
+// ── Aggregate runner ────────────────────────────────────────────
+/** Run all fleet transport checks. Check #47 only runs when ctx.fleetLivePing is true. */
+export async function runFleetTransportChecks(ctx) {
+    const results = [
+        await checkFleetTransportDelivery(ctx),
+        await checkFleetTransportErrorRate(ctx),
+        ...(await checkPerAgentDelivery(ctx)),
+        await checkFleetConfigValidation(ctx),
+        await checkFleetGatewayVersionCompat(ctx),
+        await checkFleetGlobalPackageVersion(ctx),
+        await checkFleetCallGatewayResolution(ctx),
+        await checkFleetAcpDispatchStatus(ctx),
+    ];
+    if (ctx?.fleetLivePing) {
+        results.push(await checkFleetLivePing(ctx));
+    }
+    return results;
+}
+// ── Utilities ───────────────────────────────────────────────────
+function pct(rate) {
+    return `${Math.round(rate * 100)}%`;
+}
+/**
+ * Compare two version strings (supports both semver "x.y.z" and
+ * OpenClaw's "yyyy.m.p" format). Returns -1, 0, or 1.
+ */
+export function compareVersions(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const na = pa[i] ?? 0;
+        const nb = pb[i] ?? 0;
+        if (na < nb)
+            return -1;
+        if (na > nb)
+            return 1;
+    }
+    return 0;
+}
+/** Search well-known paths for fleet-bus package.json. */
+function findFleetBusPackageJson() {
+    const candidates = [
+        path.join(process.env.HOME || '', 'node_modules', '@aiassesstech', 'fleet-bus', 'package.json'),
+        path.join(resolveOpenClawHome(), 'extensions', 'mighty-mark', 'node_modules', '@aiassesstech', 'fleet-bus', 'package.json'),
+        '/usr/lib/node_modules/@aiassesstech/fleet-bus/package.json',
+        '/usr/local/lib/node_modules/@aiassesstech/fleet-bus/package.json',
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+//# sourceMappingURL=fleet-transport.js.map