@syengup/friday-channel-next 0.0.45 → 0.1.1

package/dist/index.js

@@ -9,6 +9,7 @@ import { sseEmitter } from "./src/sse/emitter.js";
 import { forwardAgentEventRaw, getLastRegisteredFridayDeviceId, resolveFridayDeviceIdForSessionKey, } from "./src/friday-session.js";
 import { setFridayAgentForwardRuntime } from "./src/agent-forward-runtime.js";
 import { getOpenClawAgentRunContext } from "./src/agent-run-context-bridge.js";
+import { accumulateRunUsage } from "./src/agent/run-usage-accumulator.js";
 export { fridayNextChannelPlugin } from "./src/channel.js";
 export { setFridayNextRuntime } from "./src/runtime.js";
 /** `api.on` returns void — register tool hooks at most once per process. */
@@ -95,6 +96,15 @@ export default defineChannelPluginEntry({
                 sessionKey: evt.sessionKey,
             });
         });
+        api.on("llm_output", (event) => {
+            accumulateRunUsage(event.runId, {
+                input: event.usage?.input,
+                output: event.usage?.output,
+                cacheRead: event.usage?.cacheRead,
+                cacheWrite: event.usage?.cacheWrite,
+                total: event.usage?.total,
+            }, event.model, event.provider);
+        });
         if (fridayNextToolHooksRegistered) {
             return;
         }

package/dist/src/agent/run-usage-accumulator.d.ts

@@ -0,0 +1,13 @@
+import type { FridaySessionUsagePayload } from "../session-usage-snapshot.js";
+type UsageFields = {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    total?: number;
+};
+export declare function accumulateRunUsage(runId: string, usage: UsageFields, model?: string, provider?: string): void;
+export declare function consumeRunUsage(runId: string): FridaySessionUsagePayload | undefined;
+/** Vitest-only. */
+export declare function resetRunUsageAccumulatorForTest(): void;
+export {};

package/dist/src/agent/run-usage-accumulator.js

@@ -0,0 +1,58 @@
+const usageByRunId = new Map();
+function ensure(runId) {
+    let entry = usageByRunId.get(runId);
+    if (!entry) {
+        entry = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+        usageByRunId.set(runId, entry);
+    }
+    return entry;
+}
+export function accumulateRunUsage(runId, usage, model, provider) {
+    if (!runId.trim())
+        return;
+    const entry = ensure(runId);
+    if (typeof usage.input === "number" && usage.input > 0)
+        entry.input += usage.input;
+    if (typeof usage.output === "number" && usage.output > 0)
+        entry.output += usage.output;
+    if (typeof usage.cacheRead === "number" && usage.cacheRead > 0)
+        entry.cacheRead += usage.cacheRead;
+    if (typeof usage.cacheWrite === "number" && usage.cacheWrite > 0)
+        entry.cacheWrite += usage.cacheWrite;
+    if (typeof usage.total === "number" && usage.total > 0)
+        entry.total += usage.total;
+    if (model && model.trim())
+        entry.model = model.trim();
+    if (provider && provider.trim())
+        entry.provider = provider.trim();
+}
+export function consumeRunUsage(runId) {
+    const entry = usageByRunId.get(runId);
+    if (!entry)
+        return undefined;
+    usageByRunId.delete(runId);
+    const tokens = {};
+    if (entry.input > 0)
+        tokens.input = entry.input;
+    if (entry.output > 0)
+        tokens.output = entry.output;
+    if (entry.cacheRead > 0)
+        tokens.cacheRead = entry.cacheRead;
+    if (entry.cacheWrite > 0)
+        tokens.cacheWrite = entry.cacheWrite;
+    if (entry.total > 0)
+        tokens.total = entry.total;
+    tokens.totalFresh = true;
+    if (Object.keys(tokens).length === 1)
+        return undefined; // only totalFresh, no actual tokens
+    const payload = { tokens };
+    if (entry.model)
+        payload.modelId = entry.model;
+    if (entry.provider)
+        payload.modelProvider = entry.provider;
+    return payload;
+}
+/** Vitest-only. */
+export function resetRunUsageAccumulatorForTest() {
+    usageByRunId.clear();
+}

package/dist/src/friday-session.js

@@ -4,6 +4,7 @@ import { toSessionStoreKey } from "./session/session-manager.js";
 import { getOpenClawAgentRunContext } from "./agent-run-context-bridge.js";
 import { observeAgentEventForActiveRuns } from "./agent/active-runs.js";
 import { getRunMetadata, ingestAgentEventMetadata } from "./run-metadata.js";
+import { consumeRunUsage } from "./agent/run-usage-accumulator.js";
 import { buildSessionUsageSnapshot } from "./session-usage-snapshot.js";
 import { lookupByRunId, registerSessionKeyForRun, registerSpawnIntent, consumeSpawnIntent, ensureSubagentFromSpawnTool, registerEnded as registerSubagentEnded, } from "./agent/subagent-registry.js";
 /** Last `data.text` per run for `stream: "thinking"` — OpenClaw core may send cumulative `delta`; we rewrite true increments for the app. */
@@ -162,6 +163,59 @@ function tryReadSessionUsageFromStore(sessionKeyForStore) {
         return undefined;
     }
 }
+function buildSessionUsageFromRunMetadata(runId) {
+    const meta = getRunMetadata(runId);
+    if (!meta)
+        return undefined;
+    const payload = {};
+    if (typeof meta.modelName === "string" && meta.modelName.trim()) {
+        payload.modelId = meta.modelName.trim();
+    }
+    if (typeof meta.modelProvider === "string" && meta.modelProvider.trim()) {
+        payload.modelProvider = meta.modelProvider.trim();
+    }
+    const tokens = {};
+    if (typeof meta.inputTokens === "number")
+        tokens.input = meta.inputTokens;
+    if (typeof meta.outputTokens === "number")
+        tokens.output = meta.outputTokens;
+    if (typeof meta.cacheReadTokens === "number")
+        tokens.cacheRead = meta.cacheReadTokens;
+    if (typeof meta.cacheWriteTokens === "number")
+        tokens.cacheWrite = meta.cacheWriteTokens;
+    if (typeof meta.totalTokens === "number")
+        tokens.total = meta.totalTokens;
+    if (Object.keys(tokens).length > 0)
+        payload.tokens = tokens;
+    const context = {};
+    if (typeof meta.contextWindowMax === "number")
+        context.windowMax = meta.contextWindowMax;
+    if (typeof meta.totalTokens === "number")
+        context.used = meta.totalTokens;
+    if (Object.keys(context).length > 0)
+        payload.context = context;
+    if (!payload.modelId && !payload.modelProvider && !payload.tokens && !payload.context) {
+        return undefined;
+    }
+    return payload;
+}
+function mergeUsage(llmUsage, memUsage) {
+    if (!llmUsage && !memUsage)
+        return undefined;
+    if (!llmUsage)
+        return memUsage;
+    if (!memUsage)
+        return llmUsage;
+    // llm_output tokens are authoritative (per API call, no race);
+    // RunMetadata fills context window gaps.
+    return {
+        modelId: llmUsage.modelId ?? memUsage.modelId,
+        modelProvider: llmUsage.modelProvider ?? memUsage.modelProvider,
+        tokens: llmUsage.tokens,
+        context: memUsage.context ?? llmUsage.context,
+        estimatedCostUsd: llmUsage.estimatedCostUsd ?? memUsage.estimatedCostUsd,
+    };
+}
 function completeAgentEventForward(params) {
     const { evt, sk, deviceIdRaw, outgoingData, isTerminalLifecycle, subagentMeta } = params;
     observeAgentEventForActiveRuns({ stream: evt.stream, runId: evt.runId, data: outgoingData });
@@ -366,23 +420,38 @@ export function forwardAgentEventRaw(evt) {
             }, ended.deviceId);
         }
     }
-    if (isTerminalLifecycle && getFridayAgentForwardRuntime()) {
-        setImmediate(() => {
-            let data = outgoingData;
-            const usage = tryReadSessionUsageFromStore(sk);
+    // Build sessionUsage: llm_output hook (primary, no race) → store read (fallback).
+    if (isTerminalLifecycle) {
+        const llmUsage = consumeRunUsage(evt.runId);
+        const memUsage = buildSessionUsageFromRunMetadata(evt.runId);
+        const hasRealTokens = llmUsage?.tokens && Object.keys(llmUsage.tokens).length > 1;
+        if (hasRealTokens) {
+            const usage = mergeUsage(llmUsage, memUsage);
             if (usage) {
-                data = { ...outgoingData, sessionUsage: usage };
+                outgoingData = { ...outgoingData, sessionUsage: usage };
             }
-            completeAgentEventForward({
-                evt,
-                sk,
-                deviceIdRaw,
-                outgoingData: data,
-                isTerminalLifecycle: true,
-                subagentMeta,
-            });
-        });
-        return;
+        }
+        else if (getFridayAgentForwardRuntime()) {
+            // llm_output hook fires async ~20ms after lifecycle.end.
+            // Wait 100ms then re-check before falling back to store read.
+            setTimeout(() => {
+                let data = outgoingData;
+                const retryLlm = consumeRunUsage(evt.runId);
+                const usage = mergeUsage(retryLlm, memUsage) ?? tryReadSessionUsageFromStore(sk);
+                if (usage) {
+                    data = { ...outgoingData, sessionUsage: usage };
+                }
+                completeAgentEventForward({
+                    evt,
+                    sk,
+                    deviceIdRaw,
+                    outgoingData: data,
+                    isTerminalLifecycle: true,
+                    subagentMeta,
+                });
+            }, 100);
+            return;
+        }
     }
     completeAgentEventForward({
         evt,

package/dist/src/health/self-health.d.ts

@@ -0,0 +1,39 @@
+export interface SelfHealthOptions {
+    enabled: boolean;
+    checkIntervalMs: number;
+    selfHeal: boolean;
+}
+interface CheckResult {
+    name: string;
+    status: "ok" | "degraded" | "failed";
+    detail: string;
+}
+interface RepairAction {
+    component: string;
+    action: string;
+    result: "ok" | "failed" | "skipped";
+    detail: string;
+}
+export interface SelfHealthReport {
+    timestamp: number;
+    checks: CheckResult[];
+    repairs: RepairAction[];
+    overallStatus: "ok" | "degraded" | "failed";
+}
+export declare class HealthCheckRunner {
+    private timer;
+    private options;
+    constructor(options?: Partial<SelfHealthOptions>);
+    updateOptions(opts: Partial<SelfHealthOptions>): void;
+    start(_api: unknown): void;
+    stop(): void;
+    runCheck(): Promise<SelfHealthReport>;
+    private checkConfig;
+    private checkSseEmitter;
+    private checkActiveRuns;
+    private repairConfig;
+    private repairSseEmitter;
+}
+export declare function getHealthCheckRunner(): HealthCheckRunner;
+export declare function resetHealthCheckRunnerForTest(): void;
+export {};

package/dist/src/health/self-health.js

@@ -0,0 +1,174 @@
+import { resolveFridayNextConfig } from "../config.js";
+import { getHostOpenClawConfigSnapshot } from "../host-config.js";
+import { getFridayNextRuntime } from "../runtime.js";
+import { sseEmitter } from "../sse/emitter.js";
+import { getActiveRunCount } from "../agent/active-runs.js";
+import { createFridayNextLogger } from "../logging.js";
+const log = createFridayNextLogger("health-runner", "info");
+export class HealthCheckRunner {
+    timer = null;
+    options;
+    constructor(options = {}) {
+        this.options = {
+            enabled: options.enabled ?? true,
+            checkIntervalMs: options.checkIntervalMs ?? 60_000,
+            selfHeal: options.selfHeal ?? true,
+        };
+    }
+    updateOptions(opts) {
+        Object.assign(this.options, opts);
+    }
+    start(_api) {
+        this.stop();
+        if (!this.options.enabled) {
+            log.info("Self-health check disabled by config");
+            return;
+        }
+        log.info(`Starting self-health checks every ${this.options.checkIntervalMs}ms`);
+        this.timer = setInterval(() => {
+            this.runCheck().catch((err) => {
+                log.error(`Self-health check error: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }, this.options.checkIntervalMs);
+        if (this.timer && typeof this.timer.unref === "function") {
+            this.timer.unref();
+        }
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    async runCheck() {
+        const report = {
+            timestamp: Date.now(),
+            checks: [],
+            repairs: [],
+            overallStatus: "ok",
+        };
+        report.checks.push(this.checkConfig());
+        report.checks.push(this.checkSseEmitter());
+        report.checks.push(this.checkActiveRuns());
+        if (this.options.selfHeal) {
+            const configCheck = report.checks[0];
+            if (configCheck.status === "failed") {
+                report.repairs.push(await this.repairConfig());
+            }
+            const sseCheck = report.checks[1];
+            if (sseCheck.status === "failed") {
+                report.repairs.push(await this.repairSseEmitter());
+            }
+        }
+        const statuses = report.checks.map((c) => c.status);
+        if (statuses.includes("failed")) {
+            report.overallStatus = "failed";
+        }
+        else if (statuses.includes("degraded")) {
+            report.overallStatus = "degraded";
+        }
+        if (report.overallStatus !== "ok" || report.repairs.length > 0) {
+            log.warn(`Self-health result: ${report.overallStatus}, ` +
+                `checks=${report.checks.length}, repairs=${report.repairs.length}`);
+        }
+        return report;
+    }
+    checkConfig() {
+        try {
+            const runtime = getFridayNextRuntime();
+            if (!runtime?.config) {
+                return { name: "config", status: "failed", detail: "Runtime config loader not available" };
+            }
+            const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(runtime.config));
+            if (!cfg.authToken) {
+                return { name: "config", status: "degraded", detail: "authToken is empty; all requests will 401" };
+            }
+            return { name: "config", status: "ok", detail: "Config resolved with authToken" };
+        }
+        catch (err) {
+            return {
+                name: "config",
+                status: "failed",
+                detail: `Config resolution error: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    checkSseEmitter() {
+        try {
+            const connCount = sseEmitter.getConnectionCount();
+            return {
+                name: "sseEmitter",
+                status: "ok",
+                detail: `Active connections: ${connCount}`,
+            };
+        }
+        catch (err) {
+            return {
+                name: "sseEmitter",
+                status: "failed",
+                detail: `Emitter check error: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    checkActiveRuns() {
+        try {
+            const count = getActiveRunCount();
+            return {
+                name: "activeRuns",
+                status: "ok",
+                detail: `Active runs: ${count}`,
+            };
+        }
+        catch (err) {
+            return {
+                name: "activeRuns",
+                status: "failed",
+                detail: `Active runs check error: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    async repairConfig() {
+        try {
+            const runtime = getFridayNextRuntime();
+            if (!runtime?.config) {
+                return {
+                    component: "config",
+                    action: "re-resolve config",
+                    result: "failed",
+                    detail: "Runtime config loader not available",
+                };
+            }
+            resolveFridayNextConfig(getHostOpenClawConfigSnapshot(runtime.config));
+            return { component: "config", action: "re-resolve config", result: "ok", detail: "Config re-resolved" };
+        }
+        catch (err) {
+            return {
+                component: "config",
+                action: "re-resolve config",
+                result: "failed",
+                detail: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    async repairSseEmitter() {
+        return {
+            component: "sseEmitter",
+            action: "verify emitter",
+            result: "ok",
+            detail: "SSE emitter singleton is accessible",
+        };
+    }
+}
+let healthCheckRunner = null;
+export function getHealthCheckRunner() {
+    if (!healthCheckRunner) {
+        healthCheckRunner = new HealthCheckRunner();
+    }
+    return healthCheckRunner;
+}
+export function resetHealthCheckRunnerForTest() {
+    if (healthCheckRunner) {
+        healthCheckRunner.stop();
+        healthCheckRunner = null;
+    }
+}

package/dist/src/http/handlers/health.d.ts

@@ -0,0 +1,23 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export interface HealthComponentStatus {
+    status: "ok" | "degraded" | "failed" | "pending" | "not_found";
+    detail: string;
+    [key: string]: unknown;
+}
+interface RepairAction {
+    component: string;
+    action: string;
+    result: "ok" | "failed";
+    detail: string;
+}
+export interface HealthCheckResult {
+    ok: boolean;
+    timestamp: number;
+    deviceId: string;
+    nodeDeviceId: string;
+    devicePairing?: HealthComponentStatus;
+    nodePairing?: HealthComponentStatus;
+    repairActions?: RepairAction[];
+}
+export declare function handleHealth(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+export {};

package/dist/src/http/handlers/health.js

@@ -0,0 +1,225 @@
+import { listDevicePairing, approveDevicePairing } from "openclaw/plugin-sdk/device-bootstrap";
+import { extractBearerToken } from "../middleware/auth.js";
+import { loadNodePairingModule } from "../../agent/node-pairing-bridge.js";
+import { createFridayNextLogger } from "../../logging.js";
+const REQUIRED_NODE_CAPS = ["location", "canvas"];
+const REQUIRED_NODE_COMMANDS = [
+    "location.get",
+    "canvas.present",
+    "canvas.hide",
+    "canvas.navigate",
+    "canvas.eval",
+    "canvas.snapshot",
+    "canvas.a2ui.push",
+    "canvas.a2ui.pushJSONL",
+    "canvas.a2ui.reset",
+];
+export async function handleHealth(req, res) {
+    if (req.method !== "GET") {
+        res.statusCode = 405;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Method Not Allowed" }));
+        return true;
+    }
+    const token = extractBearerToken(req);
+    if (!token) {
+        res.statusCode = 401;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Unauthorized: bearer token mismatch" }));
+        return true;
+    }
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const deviceId = (url.searchParams.get("deviceId") ?? "").trim();
+    const nodeDeviceId = (url.searchParams.get("nodeDeviceId") ?? "").trim();
+    const selfHeal = (url.searchParams.get("selfHeal") ?? "").toLowerCase() === "true";
+    const result = {
+        ok: true,
+        timestamp: Date.now(),
+        deviceId,
+        nodeDeviceId,
+    };
+    const log = createFridayNextLogger("health");
+    if (deviceId) {
+        result.devicePairing = await checkDevicePairing(deviceId, selfHeal, result, log);
+    }
+    if (nodeDeviceId) {
+        result.nodePairing = await checkNodePairing(nodeDeviceId, selfHeal, result, log);
+    }
+    const statuses = [
+        result.devicePairing?.status,
+        result.nodePairing?.status,
+    ].filter(Boolean);
+    result.ok = statuses.length === 0 || statuses.every((s) => s === "ok" || s === "pending");
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(result));
+    return true;
+}
+async function checkDevicePairing(deviceId, selfHeal, result, log) {
+    const normalizedDeviceId = deviceId.trim().toUpperCase();
+    let pairing;
+    try {
+        pairing = await listDevicePairing();
+    }
+    catch (err) {
+        log.error(`listDevicePairing failed: ${err instanceof Error ? err.message : String(err)}`);
+        return {
+            status: "failed",
+            detail: `listDevicePairing failed: ${err instanceof Error ? err.message : String(err)}`,
+            devicePaired: false,
+        };
+    }
+    const pairedDevice = (pairing?.paired ?? []).find((entry) => entry.deviceId?.trim().toUpperCase() === normalizedDeviceId);
+    if (pairedDevice) {
+        const approvedScopes = pairedDevice.approvedScopes ?? [];
+        const tokens = pairedDevice.tokens ?? {};
+        const hasValidToken = Object.values(tokens).some((t) => !t.revokedAtMs);
+        if (approvedScopes.length === 0 || !hasValidToken) {
+            const issues = [];
+            if (approvedScopes.length === 0)
+                issues.push("no approved scopes");
+            if (!hasValidToken)
+                issues.push("all tokens revoked");
+            return {
+                status: "degraded",
+                detail: `Device paired but degraded: ${issues.join(", ")}`,
+                devicePaired: true,
+                approvedScopesEmpty: approvedScopes.length === 0,
+                tokensRevoked: !hasValidToken,
+            };
+        }
+        return { status: "ok", detail: "Device paired and healthy", devicePaired: true };
+    }
+    const pendingDevice = (pairing?.pending ?? []).find((entry) => entry.deviceId?.trim().toUpperCase() === normalizedDeviceId);
+    if (pendingDevice && selfHeal) {
+        try {
+            const approved = await approveDevicePairing(pendingDevice.requestId);
+            const succeeded = approved && approved.status === "approved";
+            (result.repairActions ??= []).push({
+                component: "devicePairing",
+                action: "approveDevicePairing",
+                result: succeeded ? "ok" : "failed",
+                detail: succeeded
+                    ? `Auto-approved device ${normalizedDeviceId}`
+                    : `approveDevicePairing returned status=${approved?.status ?? "null"}`,
+            });
+            if (succeeded) {
+                log.info(`Auto-approved device ${normalizedDeviceId}`);
+                return { status: "ok", detail: "Device was pending, auto-approved", devicePaired: true };
+            }
+        }
+        catch (err) {
+            log.error(`approveDevicePairing failed: ${err instanceof Error ? err.message : String(err)}`);
+            (result.repairActions ??= []).push({
+                component: "devicePairing",
+                action: "approveDevicePairing",
+                result: "failed",
+                detail: err instanceof Error ? err.message : String(err),
+            });
+        }
+        return {
+            status: "degraded",
+            detail: "Device pending but auto-approve failed",
+            devicePaired: false,
+        };
+    }
+    if (pendingDevice) {
+        return { status: "pending", detail: "Device is pending approval", devicePaired: false };
+    }
+    return { status: "not_found", detail: `Device ${normalizedDeviceId} not registered`, devicePaired: false };
+}
+async function checkNodePairing(nodeDeviceId, selfHeal, result, log) {
+    const normalizedNodeId = nodeDeviceId.trim().toUpperCase();
+    let listData, listNodePairing, approveNodePairing;
+    try {
+        ({ listNodePairing, approveNodePairing } = await loadNodePairingModule());
+    }
+    catch (err) {
+        log.error(`loadNodePairingModule failed: ${err instanceof Error ? err.message : String(err)}`);
+        return {
+            status: "failed",
+            detail: `loadNodePairingModule failed: ${err instanceof Error ? err.message : String(err)}`,
+            nodePaired: false,
+        };
+    }
+    try {
+        listData = await listNodePairing();
+    }
+    catch (err) {
+        log.error(`listNodePairing failed: ${err instanceof Error ? err.message : String(err)}`);
+        return {
+            status: "failed",
+            detail: `listNodePairing failed: ${err instanceof Error ? err.message : String(err)}`,
+            nodePaired: false,
+        };
+    }
+    const pairedNodes = listData?.paired ?? [];
+    const pairedMatch = pairedNodes.find((entry) => entry.nodeId?.trim().toUpperCase() === normalizedNodeId);
+    if (pairedMatch) {
+        const caps = pairedMatch.caps ?? [];
+        const commands = pairedMatch.commands ?? [];
+        const hasRequiredCaps = REQUIRED_NODE_CAPS.every((c) => caps.includes(c));
+        const hasRequiredCommands = REQUIRED_NODE_COMMANDS.every((c) => commands.includes(c));
+        const capsValid = caps.length > 0 && hasRequiredCaps;
+        const commandsValid = commands.length > 0 && hasRequiredCommands;
+        if (capsValid && commandsValid) {
+            return {
+                status: "ok",
+                detail: `Node paired with ${caps.length} caps, ${commands.length} commands`,
+                nodePaired: true,
+                capsCount: caps.length,
+                commandsCount: commands.length,
+                capsValid: true,
+                commandsValid: true,
+            };
+        }
+        return {
+            status: "degraded",
+            detail: `Node paired but caps/commands incomplete: caps=${caps.length} (valid=${capsValid}), commands=${commands.length} (valid=${commandsValid})`,
+            nodePaired: true,
+            capsCount: caps.length,
+            commandsCount: commands.length,
+            capsValid,
+            commandsValid,
+        };
+    }
+    const pendingNodes = listData?.pending ?? [];
+    const pendingMatch = pendingNodes.find((entry) => entry.nodeId?.trim().toUpperCase() === normalizedNodeId);
+    if (pendingMatch && selfHeal) {
+        try {
+            const callerScopes = ["operator.admin", "operator.pairing", "operator.read", "operator.write"];
+            const approved = await approveNodePairing(pendingMatch.requestId, { callerScopes });
+            const succeeded = approved != null && !("status" in approved && approved.status === "forbidden") && "requestId" in approved;
+            (result.repairActions ??= []).push({
+                component: "nodePairing",
+                action: "approveNodePairing",
+                result: succeeded ? "ok" : "failed",
+                detail: succeeded
+                    ? `Auto-approved node ${normalizedNodeId}`
+                    : `approveNodePairing returned status=${approved?.status ?? "null"}`,
+            });
+            if (succeeded) {
+                log.info(`Auto-approved node ${normalizedNodeId}`);
+                return { status: "ok", detail: "Node was pending, auto-approved", nodePaired: true };
+            }
+        }
+        catch (err) {
+            log.error(`approveNodePairing failed: ${err instanceof Error ? err.message : String(err)}`);
+            (result.repairActions ??= []).push({
+                component: "nodePairing",
+                action: "approveNodePairing",
+                result: "failed",
+                detail: err instanceof Error ? err.message : String(err),
+            });
+        }
+        return {
+            status: "degraded",
+            detail: "Node pending but auto-approve failed",
+            nodePaired: false,
+        };
+    }
+    if (pendingMatch) {
+        return { status: "pending", detail: "Node is pending approval", nodePaired: false };
+    }
+    return { status: "not_found", detail: `Node ${normalizedNodeId} not registered`, nodePaired: false };
+}