@senpi/runtime 1.0.95-dev.runtime-phase-2-api.20260507130312 → 1.0.95-dev.runtime-phase-2-api.20260507134852

package/dist/plugin.js

@@ -1,1055 +0,0 @@
-/**
- * Senpi core trading plugin — single plugin exposing all core features:
- * actions, scanners, dsl, risk, health.
- *
- * This file is the actual plugin implementation. It is loaded via the wrapper
- * at `src/index.ts`, which imports `dd-trace/initialize.mjs` first so that
- * Fastify and other libraries imported below are loaded with dd-trace's
- * patches active. Do not import this file directly from production paths;
- * always go through `index.ts` so tracing is set up correctly.
- *
- * Default export: OpenClaw plugin entry (register(api)).
- * Named export run(): programmatic/standalone entry.
- */
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { SenpiClient } from "./senpi/client.js";
-import { buildRuntimeStateDir, archiveStateDir } from "./runtime/state-layout.js";
-import { registerSenpiCli } from "./cli/senpi-commands.js";
-import { readSenpiCliStore, resolveSenpiApiKeyFromStore, resolveSenpiBaseStateDir, resolveTelegramChatIdFromStore, } from "./cli/senpi-cli-config.js";
-import { getDefaultStateDir } from "./runtime/default-state-dir.js";
-import { createNotificationService } from "./runtime/notifications.js";
-import { run } from "./runtime/run.js";
-import { AutoUpdateCoordinator } from "./runtime/auto-update/coordinator.js";
-import { runCommand } from "./runtime/auto-update/command-runner.js";
-import { resolveAutoUpdateConfig } from "./runtime/auto-update/types.js";
-import { createScannerProvidersForRun } from "./runtime/create-scanner-providers-for-run.js";
-import { initDsl } from "./dsl/index.js";
-import { initHealth } from "./health/index.js";
-import { initRisk } from "./risk/index.js";
-import { VERSION } from "./version.js";
-import { BUS_EVENT_MAP } from "./tracking/constants.js";
-import { createPluginEventTracker } from "./tracking/plugin-event-tracker.js";
-import { getLogLevel, getLogLevelSource, parseLogLevel, setErrorNotifier, setLogLevel, } from "./utils/logger.js";
-import { ExternalScannerIngestError, } from "./scanners/external-scanner-receiver.js";
-import { createLogger } from "./utils/logger.js";
-import { loadApiConfig } from "./runtime-api/config.js";
-import { startApi } from "./runtime-api/lifecycle.js";
-import { ingestSignalsHandler } from "./runtime-api/handlers/ingest-signals.js";
-/** Initialize all core features (DSL, risk, health) on the given event bus. */
-export function initCore(bus) {
-    initDsl(bus);
-    initRisk(bus);
-    initHealth(bus);
-}
-// DSL feature (exit/dsl component, types, config)
-export { initDsl, DslPlugin, dslLogger, setDslLogLevel, parseDslPluginConfig, DslConfigValidationError, dslValidationIssue, EVENTS as DslEvents, DSL_EVENTS, } from "./dsl/index.js";
-// Risk feature (placeholder)
-export { initRisk } from "./risk/index.js";
-// Health feature
-export { createHealthStateModule, initHealth } from "./health/index.js";
-// Shared types
-export { HOOK_EVENT } from './types/index.js';
-export { ScanStatus } from './types/index.js';
-export { DecisionEngine, LlmDecisionStrategy, NoDecisionStrategy, } from './actions/decision-engine.js';
-export { OpenClawLlmDecision, AnthropicLlmDecision, createLlmDecision } from './actions/llm-decision/index.js';
-/** @deprecated Use OpenClawLlmDecision instead */
-export { OpenClawLlmDecision as LlmDecisionClient } from './actions/llm-decision/index.js';
-export { OpenPositionAction, openPositionFactory, openPositionManifest, } from './actions/open-position/open-position.action.js';
-export { ClosePositionAction, closePositionFactory, closePositionManifest, } from './actions/close-position/close-position.action.js';
-// Senpi client
-export { SenpiClient } from './senpi/index.js';
-// Scanner runtime module
-export { createScannerRuntimeModule, createSenpiScannerProviders, emergingMoversScanner, momentumScanner, oiTrackerScanner, providerInput, prescreenerScanner, PersistencePolicy, RetentionPolicy, ScanStatus as ScannerScanStatus, SkipScan, } from './scanners/index.js';
-// Runtime loader — programmatic API and OpenClaw plugin entry
-export { run } from "./runtime/run.js";
-export { loadRuntimeConfig } from "./runtime/load-runtime-config.js";
-export { Runtime } from "./runtime/runtime.js";
-function toSerializable(value, seen = new WeakSet()) {
-    if (value instanceof Error) {
-        return {
-            name: value.name,
-            message: value.message,
-            stack: value.stack,
-            cause: toSerializable(value.cause, seen),
-        };
-    }
-    if (typeof value === "bigint")
-        return value.toString();
-    if (value == null ||
-        typeof value === "string" ||
-        typeof value === "number" ||
-        typeof value === "boolean") {
-        return value;
-    }
-    if (Array.isArray(value))
-        return value.map((v) => toSerializable(v, seen));
-    if (typeof value === "object") {
-        const obj = value;
-        if (seen.has(obj))
-            return "[Circular]";
-        seen.add(obj);
-        const out = {};
-        for (const key of Object.keys(obj).sort()) {
-            out[key] = toSerializable(obj[key], seen);
-        }
-        seen.delete(obj);
-        return out;
-    }
-    return String(value);
-}
-function stringifyForTelegram(value) {
-    try {
-        return JSON.stringify(toSerializable(value), null, 2);
-    }
-    catch {
-        return String(value);
-    }
-}
-function trimTelegramMessage(message, maxLength = 3900) {
-    if (message.length <= maxLength)
-        return message;
-    const clipped = message.slice(0, maxLength);
-    return `${clipped}\n...[truncated ${message.length - maxLength} chars]`;
-}
-function formatSharedLoggerErrorNotification(payload) {
-    const lines = [
-        "Senpi error log",
-        "source: shared-logger",
-        `timestamp: ${payload.timestamp}`,
-        `namespace: ${payload.namespace}`,
-        `level: ${payload.level}`,
-        `message: ${payload.message}`,
-    ];
-    if (payload.meta !== undefined) {
-        lines.push(`meta:\n${stringifyForTelegram(payload.meta)}`);
-    }
-    return trimTelegramMessage(lines.join("\n"));
-}
-function formatApiLoggerErrorNotification(message, meta) {
-    const msg = typeof message === "string" ? message : stringifyForTelegram(message);
-    const lines = [
-        "Senpi error log",
-        "source: plugin-api-logger",
-        `timestamp: ${new Date().toISOString()}`,
-        `message: ${msg}`,
-    ];
-    if (meta !== undefined) {
-        lines.push(`meta:\n${stringifyForTelegram(meta)}`);
-    }
-    return trimTelegramMessage(lines.join("\n"));
-}
-function fireAndForgetErrorNotification(notifications, message) {
-    if (!notifications)
-        return;
-    try {
-        void notifications.notify(message).catch(() => { });
-    }
-    catch {
-        // Intentionally swallow; error notifications must never fail call sites.
-    }
-}
-/**
- * Read the plugin version from the sibling `openclaw.plugin.json` manifest.
- * Performed once at module load — the manifest is shipped alongside the
- * compiled `dist/index.js` so the relative URL resolves at runtime.
- *
- * Falls back to the imported `VERSION` constant (compiled into the bundle)
- * if the manifest cannot be read; both should always agree.
- */
-function readPluginManifestVersion() {
-    try {
-        const manifestUrl = new URL("../openclaw.plugin.json", import.meta.url);
-        const raw = readFileSync(manifestUrl, "utf-8");
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.version === "string" && parsed.version.length > 0) {
-            return parsed.version;
-        }
-    }
-    catch {
-        // Fall through to VERSION fallback.
-    }
-    return VERSION;
-}
-const PLUGIN_MANIFEST_VERSION = readPluginManifestVersion();
-/**
- * OpenClaw plugin entry.
- * Boots from internal registry (installed_runtimes.json) in stateDir; does not read runtime list from config.
- */
-const senpiRuntimePlugin = {
-    id: "@senpi-ai/runtime",
-    name: "Senpi Trading Runtime",
-    version: VERSION,
-    description: "Senpi trading runtime plugin for OpenClaw — orchestrates scanners, actions, and DSL exit engine",
-    configSchema: {
-        parse(value) {
-            if (value && typeof value === "object" && !Array.isArray(value)) {
-                return value;
-            }
-            return {};
-        },
-    },
-    register(api) {
-        const pluginLogger = {
-            info: (...args) => api.logger.info(...args),
-            warn: (...args) => api.logger.warn(...args),
-            error: (message, meta) => api.logger.error(message, meta),
-        };
-        pluginLogger.info("[senpi-runtime] register(api) invoked");
-        const config = api.pluginConfig;
-        if (!config) {
-            pluginLogger.warn("[senpi-runtime] No plugin config found — skipping registration");
-            return;
-        }
-        if (typeof config.logLevel === "string" && config.logLevel.length > 0) {
-            const parsed = parseLogLevel(config.logLevel);
-            if (parsed !== null) {
-                setLogLevel(parsed, "config");
-            }
-            else {
-                pluginLogger.warn(`[senpi-runtime] Ignoring invalid plugin config logLevel="${config.logLevel}" (expected debug|info|warn|error); keeping ${getLogLevel()}.`);
-            }
-        }
-        const startupLogLevel = getLogLevel();
-        const startupLogLevelSource = getLogLevelSource();
-        const logLevelSourceLabel = startupLogLevelSource === "config"
-            ? "plugin config logLevel"
-            : startupLogLevelSource === "env"
-                ? "env SENPI_LOG_LEVEL"
-                : "default";
-        pluginLogger.info(`[senpi-runtime] log level: ${startupLogLevel} (source: ${logLevelSourceLabel}). Set plugin config "logLevel" or env SENPI_LOG_LEVEL to debug|info|warn|error to override.`);
-        const senpiCliStore = readSenpiCliStore();
-        const baseStateDir = resolveSenpiBaseStateDir({
-            store: senpiCliStore,
-            configStateDir: typeof config.stateDir === "string" ? config.stateDir : undefined,
-            resolveOpenclawStateDir: typeof api.runtime?.state?.resolveStateDir === "function"
-                ? () => api.runtime.state.resolveStateDir()
-                : undefined,
-            getDefaultStateDir,
-        });
-        const mcpTransport = api.mcpTransport;
-        const apiKey = resolveSenpiApiKeyFromStore(senpiCliStore, typeof config.apiKey === "string" && config.apiKey.length > 0 ? config.apiKey : undefined);
-        if (!mcpTransport && !apiKey) {
-            pluginLogger.error("[senpi-runtime] mcpTransport or apiKey is required (provide via gateway, api, or config)");
-            return;
-        }
-        const pluginEventTracker = createPluginEventTracker(apiKey ?? process.env.SENPI_API_KEY);
-        const runtimeHandles = new Map();
-        let apiHandle;
-        // Dedicated logger for the runtime-api subtree — required because the
-        // PluginLogger surface (info/warn/error) lacks `debug`, while the
-        // Logger contract used by `runtime-api/` includes it.
-        const apiLogger = createLogger("[senpi-core][api]");
-        const lifecycleChatId = resolveTelegramChatIdFromStore(senpiCliStore);
-        const lifecycleNotifications = lifecycleChatId
-            ? createNotificationService({
-                telegram_chat_id: lifecycleChatId,
-                gateway_url: process.env.OPENCLAW_GATEWAY_URL || "http://127.0.0.1:18789",
-                gateway_token: process.env.OPENCLAW_GATEWAY_TOKEN,
-            })
-            : undefined;
-        setErrorNotifier(lifecycleNotifications
-            ? (payload) => {
-                fireAndForgetErrorNotification(lifecycleNotifications, formatSharedLoggerErrorNotification(payload));
-            }
-            : null);
-        pluginLogger.error = (message, meta) => {
-            api.logger.error(message, meta);
-            fireAndForgetErrorNotification(lifecycleNotifications, formatApiLoggerErrorNotification(message, meta));
-        };
-        const autoUpdateConfig = resolveAutoUpdateConfig(config?.autoUpdate);
-        const autoUpdateCoordinator = new AutoUpdateCoordinator({
-            enabled: true,
-            config: autoUpdateConfig,
-            packageName: "@senpi-ai/runtime",
-            currentVersion: VERSION,
-            stateDir: join(baseStateDir, "auto-update"),
-            logger: pluginLogger,
-            notify: lifecycleNotifications
-                ? (msg) => lifecycleNotifications.notify(msg)
-                : async () => { },
-            stopRuntimesForUpdate: async () => {
-                for (const [, handle] of runtimeHandles) {
-                    await handle.stop();
-                }
-            },
-            runUpdateCommand: async () => {
-                const result = await runCommand("sh", ["-lc", "yes | openclaw plugins update runtime"], {
-                    timeoutMs: 120_000,
-                });
-                if (result.code !== 0) {
-                    throw new Error(result.stderr || `openclaw plugins update failed with code ${result.code}`);
-                }
-            },
-            configFromApi: api.config,
-            loadConfig: api.runtime?.config
-                ? () => api.runtime.config.loadConfig()
-                : undefined,
-            writeConfigFile: api.runtime?.config
-                ? (c) => api.runtime.config.writeConfigFile(c)
-                : undefined,
-            pluginId: api.id,
-        });
-        api.registerService({
-            id: "senpi-runtime",
-            async start() {
-                await autoUpdateCoordinator.start();
-                const { readRegistry } = await import("./runtime/strategy-registry.js");
-                const registry = await readRegistry(baseStateDir);
-                const scannerProviders = await createScannerProvidersForRun({
-                    mcpTransport,
-                    apiKey,
-                });
-                const started = [];
-                try {
-                    for (const entry of registry.runtimes) {
-                        const hasPath = typeof entry.runtimeYamlPath === "string" && entry.runtimeYamlPath.length > 0;
-                        const hasContent = typeof entry.runtimeYamlContent === "string";
-                        if (hasPath && hasContent)
-                            continue;
-                        if (!hasPath && !hasContent)
-                            continue;
-                        const pathOrContent = entry.runtimeYamlPath ?? entry.runtimeYamlContent;
-                        const entryStateDir = buildRuntimeStateDir(baseStateDir, entry.id, entry.wallet ?? "");
-                        const handle = await run(pathOrContent, {
-                            fromPath: hasPath,
-                            stateDir: entryStateDir,
-                            mcpTransport,
-                            apiKey,
-                            scannerProviders,
-                        });
-                        runtimeHandles.set(entry.id, handle);
-                        started.push(entry.id);
-                    }
-                }
-                catch (err) {
-                    for (let i = started.length - 1; i >= 0; i--) {
-                        const h = runtimeHandles.get(started[i]);
-                        if (h)
-                            await h.stop().catch(() => { });
-                        runtimeHandles.delete(started[i]);
-                    }
-                    throw err;
-                }
-                pluginLogger.info(`[senpi-runtime] Started ${started.length} runtime${started.length === 1 ? "" : "s"}`);
-                // ── HTTP API ──────────────────────────────────────────────────────
-                // Bind the HTTP server AFTER runtimes are hydrated so `/health` and
-                // `/signals` see the live `runtimeHandles` map. Failure here triggers
-                // a full rollback (auto-update coordinator + all started handles)
-                // before re-throwing — Section 4 of the plan.
-                //
-                // SENPI_RUNTIME_API_DISABLED=true skips API startup. Used by unit
-                // tests that exercise `plugin.register()` in parallel workers without
-                // contending for the same TCP port.
-                if (process.env.SENPI_RUNTIME_API_DISABLED !== "true") {
-                    try {
-                        const apiConfig = loadApiConfig(api.pluginConfig);
-                        apiHandle = await startApi({
-                            runtimeHandles,
-                            apiConfig,
-                            logger: apiLogger,
-                            version: PLUGIN_MANIFEST_VERSION,
-                        });
-                        apiHandle.ready();
-                    }
-                    catch (err) {
-                        pluginLogger.error("[senpi-runtime] HTTP API failed to start; rolling back lifecycle", { err });
-                        // Mirror the lifecycle-stop teardown order: stop the coordinator
-                        // first so it cannot schedule a tick or call stopRuntimesForUpdate
-                        // mid-rollback, then stop every runtime handle that was hydrated
-                        // above.
-                        await autoUpdateCoordinator.stop().catch(() => { });
-                        for (let i = started.length - 1; i >= 0; i--) {
-                            const h = runtimeHandles.get(started[i]);
-                            if (h)
-                                await h.stop().catch(() => { });
-                            runtimeHandles.delete(started[i]);
-                        }
-                        throw err;
-                    }
-                }
-                if (lifecycleNotifications) {
-                    const n = started.length;
-                    lifecycleNotifications
-                        .notify(`Senpi started. ${n} runtime${n === 1 ? "" : "s"} running.`)
-                        .catch(() => { });
-                }
-                else if (started.length > 0) {
-                    pluginLogger.info("[senpi-runtime] Lifecycle notification skipped (set telegram-chat-id via `openclaw senpi config set-chat-id` or TELEGRAM_CHAT_ID / SENPI_LIFECYCLE_TELEGRAM_CHAT_ID)");
-                }
-            },
-            async stop() {
-                if (lifecycleNotifications) {
-                    lifecycleNotifications.notify("Senpi shutting down.").catch(() => { });
-                }
-                // Drain the HTTP server FIRST so in-flight POST /signals requests
-                // finish before the underlying runtime they target is torn down.
-                // `apiHandle.close()` never throws.
-                if (apiHandle) {
-                    await apiHandle.close();
-                    apiHandle = undefined;
-                }
-                // Stop the coordinator next so it cannot schedule a new tick or call
-                // stopRuntimesForUpdate() (auto-restart path after an update) while
-                // we are tearing down the handles below.
-                await autoUpdateCoordinator.stop();
-                const ids = Array.from(runtimeHandles.keys());
-                for (let i = ids.length - 1; i >= 0; i--) {
-                    const h = runtimeHandles.get(ids[i]);
-                    if (h)
-                        await h.stop();
-                    runtimeHandles.delete(ids[i]);
-                }
-                pluginLogger.info("[senpi-runtime] All runtimes stopped");
-                // Flush plugin-scoped telemetry (lifecycle.runtime.created/deleted); otherwise
-                // BatchingTransport may still hold buffered events until the interval fires.
-                await pluginEventTracker.shutdown().catch((err) => {
-                    pluginLogger.warn("[senpi-runtime] plugin telemetry shutdown failed", {
-                        err: err instanceof Error ? err.message : String(err),
-                    });
-                });
-            },
-        });
-        pluginLogger.info("[senpi-runtime] calling api.registerCli(..., { commands: ['senpi'] })");
-        api.registerCli((ctx) => {
-            pluginLogger.info("[senpi-runtime] CLI registrar callback invoked — attaching senpi subcommands to program");
-            registerSenpiCli(ctx.program);
-        }, { commands: ["senpi"] });
-        /** Gateway respond accepts (ok, payload?, error?) with error as { code, message }; plugin SDK types may omit the third arg. */
-        api.registerGatewayMethod("senpi.installRuntime", async (ctx) => {
-            const { params } = ctx;
-            const respond = ctx.respond;
-            const toError = (message) => ({ code: "INVALID_REQUEST", message });
-            const toUnavailable = (message) => ({ code: "UNAVAILABLE", message });
-            const { readRegistry, writeRegistry, validateEntry, hasId, deriveRuntimeId, sanitizeId } = await import("./runtime/strategy-registry.js");
-            const id = typeof params?.id === "string" ? params.id : undefined;
-            const runtimeYamlPath = typeof params?.runtimeYamlPath === "string" ? params.runtimeYamlPath : undefined;
-            const runtimeYamlContent = typeof params?.runtimeYamlContent === "string" ? params.runtimeYamlContent : undefined;
-            const hasPath = runtimeYamlPath !== undefined && runtimeYamlPath.length > 0;
-            const hasContent = runtimeYamlContent !== undefined;
-            if (!hasPath && !hasContent) {
-                respond(false, undefined, toError("Please provide your runtime YAML: use the create command with --path <file> or --content \"<yaml text>\"."));
-                return;
-            }
-            if (hasPath && hasContent) {
-                respond(false, undefined, toError("Please provide either a file path (--path) or YAML content (--content), not both."));
-                return;
-            }
-            const pathOrContent = runtimeYamlPath ?? runtimeYamlContent;
-            // Parse YAML first to extract name, version, and wallet for ID derivation.
-            let parsedSchemaVersion;
-            let runtimeName = "";
-            let wallet = "";
-            try {
-                const { loadRuntimeConfig } = await import("./runtime/load-runtime-config.js");
-                const { extractMajorVersion } = await import("./runtime/runtime-version.js");
-                const parsedConfig = await loadRuntimeConfig(pathOrContent, { fromPath: hasPath });
-                parsedSchemaVersion = extractMajorVersion(parsedConfig.version);
-                runtimeName = parsedConfig.name;
-                wallet = parsedConfig.strategy?.wallet ?? "";
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                respond(false, undefined, toUnavailable(`Could not start the runtime. This is usually due to invalid or incomplete YAML.\n\n${msg}`));
-                return;
-            }
-            const registry = await readRegistry(baseStateDir);
-            const resolvedId = id && id.length > 0
-                ? (sanitizeId(id) || "runtime")
-                : deriveRuntimeId(runtimeName, wallet);
-            if (hasId(registry, resolvedId)) {
-                respond(false, undefined, toError(`A runtime with id "${resolvedId}" already exists. Use a different id (e.g. --runtime-id another-name) or remove the existing one first: openclaw senpi runtime delete ${resolvedId}`));
-                return;
-            }
-            // Enforce one running runtime per wallet address
-            if (wallet) {
-                for (const [existingId, existingHandle] of runtimeHandles) {
-                    if (existingHandle.wallet === wallet) {
-                        respond(false, undefined, toError(`A runtime for wallet "${wallet}" is already running (runtime "${existingId}"). ` +
-                            `Stop it first: openclaw senpi runtime delete --id ${existingId}`));
-                        return;
-                    }
-                }
-            }
-            // Best-effort wallet ownership validation: calls the MCP server to check
-            // whether the wallet belongs to the authenticated user's strategies.
-            // If the MCP call fails (network issue, bad apiKey, server down), we warn
-            // and allow the install to proceed rather than blocking the user.
-            if (wallet) {
-                try {
-                    const client = mcpTransport
-                        ? new SenpiClient(mcpTransport)
-                        : new SenpiClient({ apiKey });
-                    if (!mcpTransport)
-                        await client.connect();
-                    try {
-                        const strategies = await client.listStrategies({ strategyAddresses: [wallet] });
-                        const match = strategies.find((s) => s.strategyWalletAddress.toLowerCase() === wallet.toLowerCase());
-                        if (!match) {
-                            pluginLogger.info("[senpi-runtime] Wallet validation failed: not owned", { wallet });
-                            respond(false, undefined, toError(`Strategy wallet "${wallet}" (YAML field: strategy.wallet) was not found in your Senpi account's strategies. ` +
-                                `Check the address for typos. ` +
-                                `To list all your strategies and their wallet addresses, call the MCP tool: strategy_list (no arguments needed). ` +
-                                `Each result includes "strategyWalletAddress" — use that value as strategy.wallet in your YAML.`));
-                            // `return` triggers the inner `finally` (disconnect) before exiting.
-                            return;
-                        }
-                        if (match.status !== "ACTIVE") {
-                            pluginLogger.info("[senpi-runtime] Wallet validation failed: strategy not active", { wallet, status: match.status, strategyId: match.id });
-                            respond(false, undefined, toError((() => {
-                                const initializingStatuses = new Set([
-                                    "SET_REFERRER_CODE", "SET_BUILDER_FEE", "SUBSCRIBE_TRADER",
-                                    "CREATE_WALLET", "FUND_WALLET", "INITIALIZE_POSITIONS",
-                                ]);
-                                const terminalStatuses = new Set([
-                                    "CLOSED", "FAILED", "CLOSING_POSITIONS", "CLOSE_STRATEGY",
-                                    "UNSUBSCRIBE_TRADER", "FUND_SOURCE_WALLET", "INACTIVE",
-                                ]);
-                                let hint;
-                                if (initializingStatuses.has(match.status)) {
-                                    hint =
-                                        `The strategy is still initializing (${match.status}). ` +
-                                            `It will reach ACTIVE automatically — wait a few minutes, then retry. ` +
-                                            `Initialization order: CREATE_WALLET → FUND_WALLET → INITIALIZE_POSITIONS → ACTIVE.`;
-                                }
-                                else if (match.status === "PAUSED") {
-                                    hint =
-                                        `The strategy is paused and cannot be used to create a runtime  — please create a new strategy instead.`;
-                                }
-                                else if (terminalStatuses.has(match.status)) {
-                                    hint =
-                                        `The strategy is closing or already closed (${match.status}). ` +
-                                            `A runtime cannot be created for a closed strategy — please create a new strategy instead.`;
-                                }
-                                else {
-                                    hint = `Only ACTIVE strategies can run a runtime.`;
-                                }
-                                return (`Strategy wallet "${wallet}" (YAML field: strategy.wallet) has status "${match.status}" — a runtime requires ACTIVE status. ` +
-                                    hint +
-                                    ` To check the latest status, call the MCP tool: strategy_list.`);
-                            })()));
-                            return;
-                        }
-                        pluginLogger.info("[senpi-runtime] Wallet validation passed", { wallet, strategyId: match.id, status: match.status });
-                    }
-                    finally {
-                        if (!mcpTransport)
-                            await client.disconnect().catch(() => { });
-                    }
-                }
-                catch (err) {
-                    // Soft-fail: validation is best-effort. If connect() or listStrategies()
-                    // throws, log a warning and let the install proceed.
-                    const msg = err instanceof Error ? err.message : String(err);
-                    pluginLogger.warn("[senpi-runtime] Could not validate strategy wallet ownership", { wallet, err: msg });
-                }
-            }
-            const entry = hasPath
-                ? { id: resolvedId, runtimeYamlPath, schemaVersion: parsedSchemaVersion, wallet }
-                : { id: resolvedId, runtimeYamlContent: runtimeYamlContent, schemaVersion: parsedSchemaVersion, wallet };
-            const valid = validateEntry(entry);
-            if (!valid.ok) {
-                respond(false, undefined, toError(valid.error));
-                return;
-            }
-            registry.runtimes.push(entry);
-            await writeRegistry(baseStateDir, registry);
-            const createdMapping = BUS_EVENT_MAP["tracking.runtime_created"];
-            pluginEventTracker.capture({
-                eventType: createdMapping.eventType,
-                category: createdMapping.category,
-                address: wallet,
-                data: {
-                    id: resolvedId,
-                    name: runtimeName,
-                    wallet,
-                    schemaVersion: parsedSchemaVersion,
-                    source: hasPath ? "file" : "inline",
-                    config: entry,
-                    timestamp: new Date().toISOString(),
-                },
-            });
-            try {
-                const scannerProviders = await createScannerProvidersForRun({
-                    mcpTransport,
-                    apiKey,
-                });
-                const entryStateDir = buildRuntimeStateDir(baseStateDir, resolvedId, wallet);
-                const handle = await run(pathOrContent, {
-                    fromPath: hasPath,
-                    stateDir: entryStateDir,
-                    mcpTransport,
-                    apiKey,
-                    scannerProviders,
-                });
-                runtimeHandles.set(resolvedId, handle);
-                respond(true, { id: resolvedId, name: runtimeName, wallet });
-            }
-            catch (err) {
-                const next = registry.runtimes.filter((e) => e.id !== resolvedId);
-                await writeRegistry(baseStateDir, { ...registry, runtimes: next });
-                const msg = err instanceof Error ? err.message : String(err);
-                respond(false, undefined, toUnavailable(`Could not start the runtime. This is usually due to invalid or incomplete YAML.\n\n${msg}`));
-            }
-        });
-        api.registerGatewayMethod("senpi.listRuntimes", async (ctx) => {
-            const respond = ctx.respond;
-            const { readRegistry } = await import("./runtime/strategy-registry.js");
-            const registry = await readRegistry(baseStateDir);
-            const runtimes = registry.runtimes.map((e) => ({
-                id: e.id,
-                wallet: e.wallet ?? "",
-                source: typeof e.runtimeYamlPath === "string" && e.runtimeYamlPath.length > 0 ? e.runtimeYamlPath : "(inline)",
-                status: runtimeHandles.has(e.id) ? "running" : "stopped",
-            }));
-            respond(true, { runtimes });
-        });
-        api.registerGatewayMethod("senpi.deleteRuntime", async (ctx) => {
-            const { params } = ctx;
-            const respond = ctx.respond;
-            const { readRegistry, writeRegistry } = await import("./runtime/strategy-registry.js");
-            const registry = await readRegistry(baseStateDir);
-            let targetId = typeof params?.id === "string" ? params.id : undefined;
-            const targetAddress = typeof params?.address === "string" ? params.address : undefined;
-            // Resolve target by address if id not provided
-            if (!targetId && targetAddress) {
-                const entry = registry.runtimes.find((e) => e.wallet === targetAddress);
-                if (!entry) {
-                    respond(false, undefined, {
-                        code: "NOT_FOUND",
-                        message: `No runtime found for wallet address "${targetAddress}".`,
-                    });
-                    return;
-                }
-                targetId = entry.id;
-            }
-            if (!targetId) {
-                respond(false, undefined, {
-                    code: "INVALID_REQUEST",
-                    message: "Please provide the runtime id or wallet address. Example: openclaw senpi runtime delete --id my-runtime",
-                });
-                return;
-            }
-            const deletedEntry = registry.runtimes.find((e) => e.id === targetId);
-            const handle = runtimeHandles.get(targetId);
-            if (!deletedEntry && !handle) {
-                respond(false, undefined, {
-                    code: "NOT_FOUND",
-                    message: `No runtime found with id "${targetId}".`,
-                });
-                return;
-            }
-            const targetWallet = deletedEntry?.wallet ??
-                handle?.wallet ??
-                (typeof targetAddress === "string" ? targetAddress : "");
-            let openPositionsAbandoned = 0;
-            let archivePath;
-            if (handle) {
-                openPositionsAbandoned = await handle.teardownDslForRuntimeDeletion();
-                await handle.stop();
-                runtimeHandles.delete(targetId);
-            }
-            // Archive state directory before removing from registry
-            if (deletedEntry) {
-                const runtimeStateDir = buildRuntimeStateDir(baseStateDir, targetId, deletedEntry.wallet ?? "");
-                const archivesDir = join(baseStateDir, "archives");
-                try {
-                    archivePath = await archiveStateDir(runtimeStateDir, archivesDir, targetId, deletedEntry.wallet ?? "");
-                    api.logger.info(`[senpi-runtime] Archived state to ${archivePath}`);
-                }
-                catch (err) {
-                    api.logger.warn("[senpi-runtime] Failed to archive state dir", { err });
-                }
-            }
-            const deletedMapping = BUS_EVENT_MAP["tracking.runtime_deleted"];
-            pluginEventTracker.capture({
-                eventType: deletedMapping.eventType,
-                category: deletedMapping.category,
-                address: targetWallet,
-                data: {
-                    id: targetId,
-                    wallet: targetWallet,
-                    schemaVersion: deletedEntry?.schemaVersion,
-                    reason: "user_initiated",
-                    openPositionsAbandoned,
-                    ...(typeof archivePath === "string" ? { archivedAt: archivePath } : {}),
-                    timestamp: new Date().toISOString(),
-                },
-            });
-            if (deletedEntry) {
-                const next = registry.runtimes.filter((e) => e.id !== targetId);
-                await writeRegistry(baseStateDir, { ...registry, runtimes: next });
-            }
-            respond(true, { id: targetId });
-        });
-        /**
-         * Gateway shim for `senpi.ingestExternalScannerData`.
-         *
-         * Thin wrapper over the shared {@link ingestSignalsHandler} that backs
-         * `POST /signals`. Both transports go through the same in-process logic;
-         * this shim only translates between the legacy gateway envelope and the
-         * shared handler's per-item discriminant.
-         *
-         * Response shape is preserved for backward compatibility with existing
-         * producers — slated for removal in Task 5 once the migration counter
-         * decays to zero (see `runtime-phase-2-api-plan.md` Section 8).
-         */
-        api.registerGatewayMethod("senpi.ingestExternalScannerData", async (ctx) => {
-            const respond = ctx.respond;
-            // TODO(s11): wire actual telemetry counter for
-            //   runtime.deprecated_gateway_ingest_call (event name, properties:
-            //   { address, scanner }). Reuse the existing tracking transport once
-            //   it is plumbed through the plugin lifecycle in S11.
-            try {
-                const { address, request } = parseGatewayExternalScannerIngestParams(ctx.params);
-                pluginLogger.info("[senpi-runtime] senpi.ingestExternalScannerData", {
-                    address,
-                    scanner: request.scanner,
-                });
-                const item = {
-                    address,
-                    scanner: request.scanner,
-                    ...(request.asset !== undefined && { asset: request.asset }),
-                    ...(request.direction !== undefined && { direction: request.direction }),
-                    ...(request.score !== undefined && { score: request.score }),
-                    ...(request.signal_type !== undefined && { signal_type: request.signal_type }),
-                    ...(request.data !== undefined && { data: request.data }),
-                    ...(request.signals !== undefined && { signals: request.signals }),
-                };
-                const result = await ingestSignalsHandler(item, {
-                    runtimeHandles,
-                    logger: apiLogger,
-                    transport: "gateway",
-                });
-                if (result.success) {
-                    respond(true, {
-                        accepted: true,
-                        address: result.address,
-                        scanner: result.scanner,
-                        timestamp: result.timestamp,
-                        signalCount: result.signalCount,
-                        contextUpdated: result.contextUpdated,
-                    });
-                    return;
-                }
-                // Preserve the legacy "Failed to ingest external scanner data: ..."
-                // prefix on UNAVAILABLE so existing callers see the same error text
-                // they see today. INVALID_REQUEST and NOT_FOUND messages are already
-                // descriptive on their own and pass through unchanged.
-                if (result.code === "UNAVAILABLE") {
-                    respond(false, undefined, {
-                        code: "UNAVAILABLE",
-                        message: `Failed to ingest external scanner data: ${result.message}`,
-                    });
-                    return;
-                }
-                respond(false, undefined, {
-                    code: result.code,
-                    message: result.message,
-                });
-            }
-            catch (error) {
-                // `parseGatewayExternalScannerIngestParams` throws synchronously for
-                // malformed routing fields. The shared handler never throws — any
-                // other error here is unexpected.
-                if (error instanceof ExternalScannerIngestError) {
-                    respond(false, undefined, {
-                        code: error.code,
-                        message: error.message,
-                    });
-                    return;
-                }
-                pluginLogger.warn("[senpi-runtime] ingestExternalScannerData error", {
-                    address: typeof ctx.params?.address === "string" ? ctx.params.address : undefined,
-                    scanner: typeof ctx.params?.scanner === "string" ? ctx.params.scanner : undefined,
-                    err: error,
-                });
-                respond(false, undefined, {
-                    code: "UNAVAILABLE",
-                    message: `Failed to ingest external scanner data: ${formatGatewayError(error)}`,
-                });
-            }
-        });
-        api.registerGatewayMethod("senpi.listDslPositions", async (ctx) => {
-            const respond = ctx.respond;
-            const runtimeId = typeof ctx.params?.runtimeId === "string" ? ctx.params.runtimeId : undefined;
-            const address = typeof ctx.params?.address === "string" ? ctx.params.address : undefined;
-            pluginLogger.info("[senpi-runtime] senpi.listDslPositions", { runtimeId, address });
-            const positions = [];
-            for (const [id, handle] of runtimeHandles) {
-                if (runtimeId && id !== runtimeId)
-                    continue;
-                if (!handle.dsl)
-                    continue;
-                try {
-                    const items = handle.dsl.listActivePositions();
-                    for (const s of items) {
-                        if (address && s.address !== address)
-                            continue;
-                        positions.push({ ...s, runtimeId: id });
-                    }
-                }
-                catch (err) {
-                    pluginLogger.warn("[senpi-runtime] listDslPositions error", { runtimeId: id, err });
-                }
-            }
-            respond(true, { positions });
-        });
-        api.registerGatewayMethod("senpi.getDslPositionState", async (ctx) => {
-            const respond = ctx.respond;
-            const asset = typeof ctx.params?.asset === "string" ? ctx.params.asset : undefined;
-            if (!asset) {
-                respond(false, undefined, { code: "INVALID_REQUEST", message: "asset is required" });
-                return;
-            }
-            const runtimeId = typeof ctx.params?.runtimeId === "string" ? ctx.params.runtimeId : undefined;
-            const address = typeof ctx.params?.address === "string" ? ctx.params.address : undefined;
-            pluginLogger.info("[senpi-runtime] senpi.getDslPositionState", { asset, runtimeId, address });
-            const matches = [];
-            for (const [id, handle] of runtimeHandles) {
-                if (runtimeId && id !== runtimeId)
-                    continue;
-                if (!handle.dsl)
-                    continue;
-                try {
-                    if (address) {
-                        const state = handle.dsl.getPositionState(address, asset);
-                        if (state)
-                            matches.push({ runtimeId: id, address, state });
-                    }
-                    else {
-                        const found = handle.dsl.findPositionByAsset(asset);
-                        if (found)
-                            matches.push({ runtimeId: id, address: found.address, state: found.state });
-                    }
-                }
-                catch (err) {
-                    pluginLogger.warn("[senpi-runtime] getDslPositionState error", { runtimeId: id, err });
-                }
-            }
-            if (matches.length === 0) {
-                respond(false, undefined, {
-                    code: "NOT_FOUND",
-                    message: `No active DSL position found for asset ${asset}`,
-                });
-                return;
-            }
-            respond(true, { positions: matches });
-        });
-        api.registerGatewayMethod("senpi.listDslArchives", async (ctx) => {
-            const respond = ctx.respond;
-            const runtimeId = typeof ctx.params?.runtimeId === "string" ? ctx.params.runtimeId : undefined;
-            const address = typeof ctx.params?.address === "string" ? ctx.params.address : undefined;
-            const limit = typeof ctx.params?.limit === "number" ? ctx.params.limit : undefined;
-            pluginLogger.info("[senpi-runtime] senpi.listDslArchives", { runtimeId, address, limit });
-            let closes = [];
-            for (const [id, handle] of runtimeHandles) {
-                if (runtimeId && id !== runtimeId)
-                    continue;
-                if (!handle.dsl)
-                    continue;
-                try {
-                    const items = await handle.dsl.listArchivedCloses({ address });
-                    for (const c of items)
-                        closes.push({ ...c, runtimeId: id });
-                }
-                catch (err) {
-                    pluginLogger.warn("[senpi-runtime] listDslArchives error", { runtimeId: id, err });
-                }
-            }
-            closes.sort((a, b) => (b.closedAt ?? "").localeCompare(a.closedAt ?? ""));
-            if (limit && limit > 0)
-                closes = closes.slice(0, limit);
-            respond(true, { closes });
-        });
-        api.registerGatewayMethod("senpi.getHealthStatus", async (ctx) => {
-            const respond = ctx.respond;
-            const updater = autoUpdateCoordinator.getSnapshot();
-            const runtimeId = typeof ctx.params?.runtimeId === "string" ? ctx.params.runtimeId : undefined;
-            if (runtimeId) {
-                const handle = getRuntimeHandleOrRespond(runtimeHandles, runtimeId, respond);
-                if (!handle) {
-                    return;
-                }
-                try {
-                    const status = await handle.getHealthStatus();
-                    respond(true, {
-                        status: status ? { ...status, runtimeId } : null,
-                        updater,
-                    });
-                }
-                catch (err) {
-                    api.logger.warn("[senpi-runtime] getHealthStatus error", { runtimeId, err });
-                    respond(false, undefined, {
-                        code: "INTERNAL_ERROR",
-                        message: `Failed to get health status for runtime ${runtimeId}: ${formatGatewayError(err)}`,
-                    });
-                }
-                return;
-            }
-            const statuses = await collectRuntimeHealthStatuses(runtimeHandles, api.logger);
-            respond(true, { statuses, updater });
-        });
-        api.registerGatewayMethod("senpi.getSystemState", async (ctx) => {
-            const respond = ctx.respond;
-            const updater = autoUpdateCoordinator.getSnapshot();
-            const runtimeId = typeof ctx.params?.runtimeId === "string" ? ctx.params.runtimeId : undefined;
-            if (runtimeId) {
-                const handle = getRuntimeHandleOrRespond(runtimeHandles, runtimeId, respond);
-                if (!handle) {
-                    return;
-                }
-                try {
-                    const state = await handle.getSystemState();
-                    respond(true, {
-                        state: state ? { ...state, runtimeId } : null,
-                        updater,
-                    });
-                }
-                catch (err) {
-                    api.logger.warn("[senpi-runtime] getSystemState error", { runtimeId, err });
-                    respond(false, undefined, {
-                        code: "INTERNAL_ERROR",
-                        message: `Failed to get system state for runtime ${runtimeId}: ${formatGatewayError(err)}`,
-                    });
-                }
-                return;
-            }
-            const states = await collectRuntimeSystemStates(runtimeHandles, api.logger, baseStateDir);
-            respond(true, { states, updater });
-        });
-        api.logger.info(`[senpi-runtime] v${VERSION} plugin registered — stateDir: ${baseStateDir}`);
-    },
-};
-function getRuntimeHandleOrRespond(runtimeHandles, runtimeId, respond) {
-    const handle = runtimeHandles.get(runtimeId);
-    if (handle) {
-        return handle;
-    }
-    respond(false, undefined, {
-        code: "NOT_FOUND",
-        message: `No running runtime found for id ${runtimeId}`,
-    });
-    return null;
-}
-/**
- * Parse the gateway request shape for `senpi.ingestExternalScannerData`.
- *
- * The plugin contract keeps `address` at the gateway layer because the plugin
- * owns the map of running runtimes keyed by runtime id, while the runtime's
- * programmatic ingest API is already scoped to one strategy wallet. This
- * helper validates only the routing-critical fields (`address`, `scanner`) and
- * forwards the remaining payload as-is so the runtime keeps ownership of the
- * external-scanner data contract.
- *
- * @deprecated Used only by the `senpi.ingestExternalScannerData` gateway shim,
- * which itself is slated for removal in Task 5 of the runtime-phase-2-api plan
- * once external producers migrate to `POST /signals`. Delete alongside the
- * gateway-method registration in that task.
- */
-function parseGatewayExternalScannerIngestParams(params) {
-    const address = typeof params?.address === "string" ? params.address.trim() : "";
-    if (!address) {
-        throw new ExternalScannerIngestError("INVALID_REQUEST", "External scanner ingest requires address as a non-empty string.");
-    }
-    const scanner = typeof params?.scanner === "string" ? params.scanner.trim() : "";
-    if (!scanner) {
-        throw new ExternalScannerIngestError("INVALID_REQUEST", "External scanner ingest requires scanner as a non-empty string.");
-    }
-    return {
-        address,
-        request: {
-            scanner,
-            asset: params?.asset,
-            direction: params?.direction,
-            score: params?.score,
-            signal_type: params?.signal_type,
-            data: params?.data,
-            signals: params?.signals,
-        },
-    };
-}
-async function collectRuntimeHealthStatuses(runtimeHandles, logger) {
-    return (await Promise.all(Array.from(runtimeHandles, async ([runtimeId, handle]) => {
-        try {
-            const status = await handle.getHealthStatus();
-            return status ? { ...status, runtimeId } : null;
-        }
-        catch (err) {
-            logger.warn("[senpi-runtime] getHealthStatus error", { runtimeId, err });
-            return createGatewayHealthErrorStatus(runtimeId, err);
-        }
-    }))).filter((status) => status !== null);
-}
-async function collectRuntimeSystemStates(runtimeHandles, logger, baseStateDir) {
-    return (await Promise.all(Array.from(runtimeHandles, async ([runtimeId, handle]) => {
-        try {
-            const state = await handle.getSystemState();
-            return state ? { ...state, runtimeId } : null;
-        }
-        catch (err) {
-            logger.warn("[senpi-runtime] getSystemState error", { runtimeId, err });
-            return createGatewaySystemStateError(runtimeId, join(baseStateDir, runtimeId), err);
-        }
-    }))).filter((state) => state !== null);
-}
-function createGatewayHealthErrorStatus(runtimeId, error) {
-    const now = new Date().toISOString();
-    const message = formatGatewayError(error);
-    return {
-        runtimeId,
-        runtimeName: runtimeId,
-        startedAt: now,
-        generatedAt: now,
-        health: "unhealthy",
-        logLevel: getLogLevel(),
-        components: {
-            scanners: {
-                component: "scanners",
-                health: "unhealthy",
-                updatedAt: now,
-                summary: "Failed to query scanners health.",
-                error: message,
-                totals: {
-                    registered: 0,
-                    enabled: 0,
-                    inFlight: 0,
-                    degraded: 0,
-                    unhealthy: 1,
-                },
-                scanners: [],
-            },
-        },
-    };
-}
-function createGatewaySystemStateError(runtimeId, stateDir, error) {
-    const now = new Date().toISOString();
-    const message = formatGatewayError(error);
-    return {
-        runtimeId,
-        runtimeName: runtimeId,
-        stateDir,
-        startedAt: now,
-        generatedAt: now,
-        health: "unhealthy",
-        logLevel: getLogLevel(),
-        components: {
-            scanners: {
-                component: "scanners",
-                health: "unhealthy",
-                updatedAt: now,
-                error: message,
-                state: {
-                    totalRegistered: 0,
-                    totalEnabled: 0,
-                    scanners: [],
-                },
-            },
-        },
-    };
-}
-function formatGatewayError(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-export default senpiRuntimePlugin;
-//# sourceMappingURL=plugin.js.map