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

package/dist/index.js

@@ -1,38 +1,1067 @@
 /**
- * Plugin entry — thin wrapper that initializes dd-trace before loading the
- * real plugin module.
+ * Senpi core trading plugin — single plugin exposing all core features:
+ * actions, scanners, dsl, risk, health.
+ * Default export: OpenClaw plugin entry (register(api)).
+ * Named export run(): programmatic/standalone entry.
  *
- * Why this file exists:
- *   ESM hoists static `import` statements above any module-body code. If
- *   dd-trace.init() lived inside `plugin.ts`, the `import { ... } from "fastify"`
- *   line at the top of that file would already have loaded Fastify (with
- *   un-patched prototypes) before init() ran. dd-trace can't patch modules
- *   retroactively, so the in-file gate would yield zero coverage.
- *
- *   This wrapper sidesteps the problem. ESM resolves the static imports below
- *   in source order: `dd-trace/initialize.mjs` runs first (registering the
- *   ESM loader hook + CJS require interceptors), then `./plugin.js` loads.
- *   Anything `plugin.ts` imports — Fastify, our HTTP server, the Senpi MCP
- *   client — flows through dd-trace's hooks and gets patched.
- *
- *   We can't rely on `NODE_OPTIONS="--require dd-trace/init"` because the
- *   openclaw container's env is owned by upstream and out of our control.
+ * Why this file is monolithic (vs. a thin wrapper that imports ./plugin.js):
+ *   openclaw 2026.2.22's plugin loader follows relative imports from the
+ *   entry through a CJS-fallback path that rejects `import.meta` syntax.
+ *   The wrapper-style entry introduced in d919805 broke loadability for
+ *   that reason. Keeping every export in a single file (this one) avoids
+ *   the loader's relative-import path entirely.
+ */
+// dd-trace init MUST be the first executable statement in this file so it
+// patches Node core modules (http, fs, etc.) before any traceable resource is
+// constructed by the imports below. Gated on DD_TRACE_ENABLED=true so unit
+// tests and standalone CLI invocations do not pay the init cost.
+// `createRequire` is used because `dd-trace` is a CJS module and our
+// tsconfig uses Node16 modules — a top-level `import "dd-trace"` would
+// be hoisted above this gate by the bundler/loader.
+import { createRequire } from "node:module";
+const __require = createRequire(import.meta.url);
+if (process.env.DD_TRACE_ENABLED === "true") {
+    __require("dd-trace").init();
+}
+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.
  *
- * Caveat — partial coverage:
- *   Modules that the OpenClaw harness already loaded before importing this
- *   plugin (e.g. its own `http` usage) are NOT patched. dd-trace can only
- *   patch modules that are loaded *after* its hooks are installed. Within
- *   our plugin's own object graph, that's everything; outside it, nothing.
+ * 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`.
  *
- * Gating:
- *   `dd-trace/initialize.mjs` reads `DD_TRACE_ENABLED` and other `DD_*` env
- *   vars internally. With no agent configured, it stays a near-no-op — no
- *   spans are emitted and the connection-failure noise is silent. Tests do
- *   not need to opt out.
+ * 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.
  *
- * Operator docs: see `docs/runtime-docs/runtime-api.md` § "Tracing (Datadog APM)".
+ * @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.
  */
-import "dd-trace/initialize.mjs";
-export { default } from "./plugin.js";
-export * from "./plugin.js";
+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=index.js.map