@senpi/runtime 3.0.0-dev.openclaw-upgrade-mai.20260623210452 → 3.0.0-dev.runtime-phase-2.20260623210537

package/dist/scanners/external/liquidation-watchdog/README.md

@@ -0,0 +1,107 @@
+# External liquidation-watchdog producer
+
+A real, standalone watchdog scanner that runs as an external producer:
+
+1. Pulls clearinghouse state from the live Senpi MCP server.
+2. Computes margin / liquidation-distance / ROE alerts using a self-contained
+   port of the watchdog logic (no dependency on the runtime's internal
+   `liquidationWatchdogScanner`).
+3. Pushes resulting signals into a running runtime via
+   `openclaw senpi external-scanner ingest` (gateway RPC `senpi.ingestExternalScannerData`).
+
+## Files
+
+- `recipe.yaml` — runtime recipe declaring the matching `external_scanner`
+  (`external_liquidation_watchdog`) and a downstream LLM action wired to
+  `{{signal_external_liquidation_watchdog}}`.
+- `producer.mjs` — the external producer entrypoint.
+
+## Prereqs
+
+1. Build the project so the MCP provider bridge is available:
+   ```bash
+   npm run build
+   ```
+2. Install the runtime from `recipe.yaml` for your strategy wallet and start it:
+   ```bash
+   openclaw senpi runtime create -p src/scanners/external/liquidation-watchdog/recipe.yaml
+   ```
+3. Ensure `openclaw` is on `PATH` and authenticated against the host running
+   that runtime.
+4. Export Senpi MCP credentials and the target wallet:
+   ```bash
+   export SENPI_API_KEY="..."
+   export SENPI_MCP_URL="https://mcp.prod.senpi.ai/mcp"
+   export STRATEGY_ADDRESS="0x..."
+   ```
+
+## Run
+
+```bash
+node src/scanners/external/liquidation-watchdog/producer.mjs
+```
+
+The producer fetches one clearinghouse snapshot, derives signals, and pushes
+them. It exits non-zero on any rejection or signal-count mismatch. Re-run
+(or wrap in `watch`/cron) for continuous monitoring.
+
+## Env
+
+| Var | Default | Purpose |
+|---|---|---|
+| `SENPI_API_KEY` | _required_ | Senpi MCP auth |
+| `SENPI_MCP_URL` | _required_ | Senpi MCP endpoint |
+| `STRATEGY_ADDRESS` | _required_ | Target wallet — must match the installed runtime |
+| `EXTERNAL_SCANNER_NAME` | `external_liquidation_watchdog` | Must match `scanners[].name` in the recipe |
+| `OPENCLAW_BIN` | `openclaw` | Path/name of the OpenClaw CLI binary |
+| `BUFFER_WARNING_PCT` | `50` | Margin buffer % below which a WARNING alert fires |
+| `BUFFER_CRITICAL_PCT` | `30` | Margin buffer % below which CRITICAL + WATCHDOG_CLOSE fire |
+| `LIQ_DISTANCE_WARNING_PCT` | `30` | Per-position liq distance % warning threshold |
+| `ROE_DANGER_PCT` | `-15` | ROE % below which a position is flagged |
+
+## Expected response
+
+```json
+{
+  "accepted": true,
+  "address": "0x...",
+  "scanner": "external_liquidation_watchdog",
+  "timestamp": 1775680200000,
+  "signalCount": 3,
+  "contextUpdated": false
+}
+```
+
+## Live test: force a watchdog close
+
+To verify the end-to-end close path on a real open position, loosen the
+producer thresholds so any healthy position trips `WATCHDOG_CLOSE`. The
+shipped `recipe.yaml` intentionally has no `exit.dsl` block, so the watchdog
+is the only exit path — a close is unambiguously attributable to the producer.
+
+```bash
+BUFFER_WARNING_PCT=99 \
+BUFFER_CRITICAL_PCT=95 \
+LIQ_DISTANCE_WARNING_PCT=99 \
+ROE_DANGER_PCT=100 \
+node src/scanners/external/liquidation-watchdog/producer.mjs
+```
+
+Expect `accepted: true` with `signalCount >= 1` and the `watchdog_close`
+action firing on the runtime. Revert the env values (and re-add a DSL preset)
+before running unattended — without DSL, nothing else will close a position
+between producer runs.
+
+## Manual e2e checklist
+
+- Happy path: live wallet with healthy positions → producer prints `0` signals
+  and skips the ingest.
+- Triggered path: wallet with a tight liq distance or low buffer → producer
+  emits `WATCHDOG_ALERT` (and `WATCHDOG_CLOSE` for critical buffer); gateway
+  returns `accepted: true` with matching `signalCount`.
+- Unknown wallet: change `STRATEGY_ADDRESS` to a wallet without an installed
+  runtime → expect `NOT_FOUND`.
+- Disabled scanner: stop the runtime or rename the scanner in the recipe →
+  expect `INVALID_REQUEST`.
+- Schema rejection: edit `toExternalBatchItem` in `producer.mjs` to drop
+  `sourceMeta` → expect a validation `INVALID_REQUEST`.

package/dist/scanners/external/liquidation-watchdog/liquidation-watchdog.yaml

@@ -0,0 +1,48 @@
+name: external-liquidation-watchdog
+version: 1.0.0
+description: >
+  External producer variant of the liquidation watchdog. Margin / liq-distance /
+  ROE alerts are computed by an out-of-process producer (see producer.mjs) and
+  pushed in via senpi.ingestExternalScannerData. Watchdog signals drive an
+  emergency CLOSE_POSITION; DSL handles normal trailing exits.
+
+strategy:
+  wallet: "${WALLET_ADDRESS}"
+  budget: 1000
+  slots: 3
+  margin_per_slot: 300
+  trading_risk: moderate
+  enabled: true
+
+scanners:
+  # External scanner: signals are pushed by producer.mjs, no internal interval.
+  # `fields` documents the payload shape the gateway will accept from the producer.
+  - name: external_liquidation_watchdog
+    type: external_scanner
+    outputs:
+      signals: true
+      context: false
+    config:
+      fields:
+        sourceScannerId: { type: string, required: true }
+        sourceSignalType: { type: string, required: true }
+        sourceTimestamp: { type: number, required: true }
+        sourceFactors: { type: object, required: true }
+        sourceMeta: { type: object, required: true }
+
+actions:
+  # Emergency close on margin danger — rule-based, no LLM in the hot path.
+  - name: watchdog_close
+    action_type: CLOSE_POSITION
+    decision_mode: rule
+    scanners: [external_liquidation_watchdog]
+    min_confidence: 1
+
+# ── NOTIFICATIONS ──
+notifications:
+  telegram_chat_id: "${TELEGRAM_CHAT_ID}"
+
+
+# No `exit:` block: for a live test we want the external watchdog to be the
+# ONLY exit path, so a triggered close is unambiguously attributable to the
+# producer. Re-add a DSL preset before running this recipe unattended.

package/dist/scanners/external/liquidation-watchdog/producer.mjs

@@ -0,0 +1,336 @@
+/**
+ * External liquidation-watchdog producer.
+ *
+ * A real, standalone watchdog scanner that:
+ *   1. Pulls clearinghouse state + active positions from the live Senpi MCP server.
+ *   2. Computes margin/liquidation/ROE alerts using the migrated watchdog logic
+ *      below (no dependency on the runtime's internal scanner).
+ *   3. Pushes resulting signals into a running runtime via the
+ *      `openclaw senpi external-scanner ingest` CLI command.
+ *
+ * Prereqs:
+ *   - `npm run build` so dist/ is current (used only for the MCP provider bridge).
+ *   - A runtime installed from ./recipe.yaml is running for STRATEGY_ADDRESS.
+ *   - `openclaw` CLI on PATH and authenticated against that runtime.
+ *   - SENPI_API_KEY and SENPI_MCP_URL env vars set.
+ *
+ * Run:  node src/scanners/external/liquidation-watchdog/producer.mjs
+ */
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { createSenpiScannerProviders } from "../../../../dist/scanners/index.js";
+import { pushScannerSignals } from "../shared/ingest.mjs";
+
+// ─── Config ─────────────────────────────────────────────────────────────────
+
+const SENPI_API_KEY = process.env.SENPI_API_KEY;
+const SENPI_MCP_URL = process.env.SENPI_MCP_URL;
+const STRATEGY_ADDRESS = process.env.STRATEGY_ADDRESS;
+const SCANNER_NAME =
+  process.env.EXTERNAL_SCANNER_NAME ?? "external_liquidation_watchdog";
+const OPENCLAW_BIN = process.env.OPENCLAW_BIN ?? "openclaw";
+const SCANNER_ID = "external-liquidation-watchdog-producer";
+
+const config = {
+  bufferWarningPct: numEnv("BUFFER_WARNING_PCT", 50),
+  bufferCriticalPct: numEnv("BUFFER_CRITICAL_PCT", 30),
+  liqDistanceWarningPct: numEnv("LIQ_DISTANCE_WARNING_PCT", 30),
+  roeDangerPct: numEnv("ROE_DANGER_PCT", -15),
+};
+
+if (!SENPI_API_KEY || !SENPI_MCP_URL || !STRATEGY_ADDRESS) {
+  console.error(
+    "Missing required env vars. Set SENPI_API_KEY, SENPI_MCP_URL, and STRATEGY_ADDRESS.\n" +
+      "  export SENPI_API_KEY='...'\n" +
+      "  export SENPI_MCP_URL='https://mcp.prod.senpi.ai/mcp'\n" +
+      "  export STRATEGY_ADDRESS='0x...'",
+  );
+  process.exit(1);
+}
+
+function numEnv(name, fallback) {
+  const raw = process.env[name];
+  if (raw === undefined || raw === "") return fallback;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Env ${name} must be a finite number, got "${raw}"`);
+  }
+  return parsed;
+}
+
+// ─── MCP → SenpiToolClient bridge ───────────────────────────────────────────
+
+function createSenpiToolClient(mcpClient) {
+  return {
+    async callTool(name, args) {
+      const result = await mcpClient.callTool({ name, arguments: args });
+
+      if (result.isError) {
+        const errorText =
+          Array.isArray(result.content) &&
+          result.content.length > 0 &&
+          result.content[0].type === "text"
+            ? result.content[0].text
+            : JSON.stringify(result.content);
+        throw new Error(`MCP tool "${name}" returned error: ${errorText}`);
+      }
+
+      if (result.structuredContent !== undefined) {
+        return result.structuredContent;
+      }
+
+      if (Array.isArray(result.content) && result.content.length > 0) {
+        const first = result.content[0];
+        if (first.type === "text") {
+          try {
+            return JSON.parse(first.text);
+          } catch {
+            return first.text;
+          }
+        }
+      }
+
+      return result.content;
+    },
+  };
+}
+
+// ─── Migrated watchdog logic ────────────────────────────────────────────────
+// Ported from src/scanners/implementations/liquidation-watchdog.ts.
+// Kept self-contained so this producer has no dependency on the internal
+// scanner implementation.
+
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+
+function resolveDirection(szi) {
+  return szi >= 0 ? "LONG" : "SHORT";
+}
+
+function computeMarkPrice(position) {
+  if (position.szi === 0) return position.entryPx;
+  return position.entryPx + position.unrealizedPnl / position.szi;
+}
+
+function normalizeRoe(returnOnEquity) {
+  return returnOnEquity * 100;
+}
+
+function normalizeWatchdogPosition(position) {
+  return {
+    asset: position.coin,
+    direction: resolveDirection(position.szi),
+    size: Math.abs(position.szi),
+    entryPrice: position.entryPx,
+    markPrice: computeMarkPrice(position),
+    liquidationPrice: position.liquidationPx,
+    unrealizedPnl: position.unrealizedPnl,
+    roe: normalizeRoe(position.returnOnEquity),
+    leverage: position.leverage,
+  };
+}
+
+function computeMarginBuffer(accountValue, withdrawable) {
+  if (accountValue <= 0) return 0;
+  return (withdrawable / accountValue) * 100;
+}
+
+function computeLiqDistance(markPrice, liqPrice, direction) {
+  if (liqPrice === null || liqPrice === undefined) return null;
+  if (liqPrice <= 0 || markPrice <= 0) return null;
+  if (direction === "LONG") {
+    return ((markPrice - liqPrice) / markPrice) * 100;
+  }
+  return ((liqPrice - markPrice) / markPrice) * 100;
+}
+
+function analyzeMarginHealth(chState, cfg) {
+  const alerts = [];
+  let lowestRoePosition = null;
+  let lowestRoe = Infinity;
+
+  const buffer = computeMarginBuffer(chState.accountValue, chState.withdrawable);
+
+  if (buffer < cfg.bufferCriticalPct) {
+    alerts.push({
+      level: "CRITICAL",
+      message: `Margin buffer CRITICAL: ${buffer.toFixed(1)}% (threshold: ${cfg.bufferCriticalPct}%)`,
+      value: buffer,
+      threshold: cfg.bufferCriticalPct,
+    });
+  } else if (buffer < cfg.bufferWarningPct) {
+    alerts.push({
+      level: "WARNING",
+      message: `Margin buffer WARNING: ${buffer.toFixed(1)}% (threshold: ${cfg.bufferWarningPct}%)`,
+      value: buffer,
+      threshold: cfg.bufferWarningPct,
+    });
+  }
+
+  for (const rawPosition of chState.positions ?? []) {
+    const pos = normalizeWatchdogPosition(rawPosition);
+
+    if (pos.roe < lowestRoe) {
+      lowestRoe = pos.roe;
+      lowestRoePosition = pos;
+    }
+
+    const liqDist = computeLiqDistance(
+      pos.markPrice,
+      pos.liquidationPrice,
+      pos.direction,
+    );
+    if (liqDist !== null && liqDist < cfg.liqDistanceWarningPct) {
+      alerts.push({
+        level: liqDist < cfg.liqDistanceWarningPct / 2 ? "CRITICAL" : "WARNING",
+        message: `Liquidation distance ${pos.asset} ${pos.direction}: ${liqDist.toFixed(1)}% (threshold: ${cfg.liqDistanceWarningPct}%)`,
+        asset: pos.asset,
+        value: liqDist,
+        threshold: cfg.liqDistanceWarningPct,
+      });
+    }
+
+    if (pos.roe < cfg.roeDangerPct) {
+      alerts.push({
+        level: "WARNING",
+        message: `ROE danger ${pos.asset}: ${pos.roe.toFixed(1)}% (threshold: ${cfg.roeDangerPct}%)`,
+        asset: pos.asset,
+        value: pos.roe,
+        threshold: cfg.roeDangerPct,
+      });
+    }
+  }
+
+  return { alerts, lowestRoePosition, marginBuffer: buffer };
+}
+
+function buildSignals({ chState, alerts, lowestRoePosition, marginBuffer, now }) {
+  const signals = [];
+
+  const hasCriticalBuffer = alerts.some(
+    (a) => a.level === "CRITICAL" && a.message.includes("Margin buffer"),
+  );
+
+  if (hasCriticalBuffer && lowestRoePosition) {
+    signals.push({
+      scannerId: SCANNER_ID,
+      signalType: "WATCHDOG_CLOSE",
+      asset: lowestRoePosition.asset,
+      direction: lowestRoePosition.direction,
+      score: clamp01(0.95),
+      timestamp: now,
+      factors: { critical_buffer: true, lowest_roe: true },
+      meta: {
+        reason: "critical_margin_buffer",
+        roe: lowestRoePosition.roe,
+        asset: lowestRoePosition.asset,
+        buffer: marginBuffer,
+        alerts: alerts.map((a) => a.message),
+      },
+    });
+  }
+
+  for (const alert of alerts) {
+    signals.push({
+      scannerId: SCANNER_ID,
+      signalType: "WATCHDOG_ALERT",
+      asset: alert.asset ?? "ACCOUNT",
+      direction: "LONG",
+      score: clamp01(alert.level === "CRITICAL" ? 0.9 : 0.5),
+      timestamp: now,
+      factors: {
+        critical: alert.level === "CRITICAL",
+        warning: alert.level === "WARNING",
+      },
+      meta: {
+        alertLevel: alert.level,
+        message: alert.message,
+        value: alert.value,
+        threshold: alert.threshold,
+      },
+    });
+  }
+
+  return signals;
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────────
+
+async function main() {
+  console.log(`External watchdog producer`);
+  console.log(`  MCP:      ${SENPI_MCP_URL}`);
+  console.log(`  address:  ${STRATEGY_ADDRESS}`);
+  console.log(`  scanner:  ${SCANNER_NAME}`);
+  console.log(`  config:   ${JSON.stringify(config)}`);
+
+  const transport = new StreamableHTTPClientTransport(new URL(SENPI_MCP_URL), {
+    requestInit: { headers: { Authorization: `Bearer ${SENPI_API_KEY}` } },
+  });
+  const mcpClient = new Client({
+    name: "external-liquidation-watchdog",
+    version: "0.0.1",
+  });
+  await mcpClient.connect(transport);
+
+  const providers = createSenpiScannerProviders({
+    client: createSenpiToolClient(mcpClient),
+    logLevel: "warn",
+    cacheTtlMs: { instruments: 0, smData: 0, candles: 0 },
+    retries: 2,
+  });
+
+  try {
+    const chState = await providers.getClearingHouseState(STRATEGY_ADDRESS);
+    if (!chState) {
+      console.warn("Clearinghouse state unavailable — skipping ingest.");
+      return;
+    }
+
+    console.log(
+      `\nClearinghouse: accountValue=$${chState.accountValue}, ` +
+        `withdrawable=$${chState.withdrawable}, positions=${chState.positions?.length ?? 0}`,
+    );
+
+    const { alerts, lowestRoePosition, marginBuffer } = analyzeMarginHealth(
+      chState,
+      config,
+    );
+    const signals = buildSignals({
+      chState,
+      alerts,
+      lowestRoePosition,
+      marginBuffer,
+      now: Date.now(),
+    });
+
+    console.log(`\nAlerts: ${alerts.length}, Signals: ${signals.length}`);
+    for (const a of alerts) {
+      console.log(`  [${a.level}] ${a.message}`);
+    }
+
+    if (signals.length === 0) {
+      console.log("\nNothing to ingest — skipping gateway call.");
+      return;
+    }
+
+    const response = await pushScannerSignals({
+      address: STRATEGY_ADDRESS,
+      scanner: SCANNER_NAME,
+      signals,
+      openclawBin: OPENCLAW_BIN,
+    });
+    console.log("\nIngest response:", JSON.stringify(response));
+  } finally {
+    await transport.close();
+  }
+}
+
+main().catch((error) => {
+  console.error("\nProducer failed:", error.message ?? error);
+  process.exit(1);
+});

package/dist/scanners/external/momentum/README.md

@@ -0,0 +1,148 @@
+# External momentum producer
+
+A standalone momentum scanner that runs as an external producer:
+
+1. Pulls instruments + latest candles from the live Senpi MCP server.
+2. Computes last-vs-prev close % move per candidate using a self-contained
+   port of the momentum scanner logic (no dependency on the runtime's internal
+   `momentumScanner`).
+3. Pushes resulting `MOMENTUM_BREAKOUT` signals into a running runtime via the
+   `senpi.ingestExternalScannerData` gateway RPC.
+
+The companion recipe wires those signals into an LLM `OPEN_POSITION` action,
+demonstrating the full e2e path from external signal → LLM gauntlet →
+Senpi MCP position open → DSL trailing-exit management.
+
+## Files
+
+- `momentum.yaml` — runtime recipe declaring the matching `external_scanner`
+  (`external_momentum`), the `momentum_entry` LLM OPEN_POSITION action, and
+  a DSL exit preset tuned for short-horizon momentum trades.
+- `producer.mjs` — the external producer entrypoint.
+
+## Prereqs
+
+1. Build the project so the MCP provider bridge is available:
+   ```bash
+   npm run build
+   ```
+2. Install the runtime from `momentum.yaml` for your strategy wallet and start it:
+   ```bash
+   openclaw senpi runtime create -p src/scanners/external/momentum/momentum.yaml
+   ```
+3. Ensure `openclaw` is on `PATH` and authenticated against the host running
+   that runtime.
+4. Export Senpi MCP credentials and the target wallet:
+   ```bash
+   export SENPI_API_KEY="..."
+   export SENPI_MCP_URL="https://mcp.prod.senpi.ai/mcp"
+   export STRATEGY_ADDRESS="0x..."
+   ```
+
+## Run
+
+```bash
+node src/scanners/external/momentum/producer.mjs
+```
+
+The producer fetches one snapshot (instruments + candles), derives signals,
+and pushes them. It exits non-zero on any rejection or signal-count mismatch.
+Re-run (or wrap in `watch`/cron) for continuous monitoring.
+
+## Schedule with OpenClaw cron
+
+The producer runs **once per invocation** — it fetches a snapshot, pushes
+signals, and exits. For continuous monitoring you need a scheduler. The
+recommended approach is to register an OpenClaw cron immediately after
+creating the runtime strategy, and let your agent wire it up.
+
+Ask your agent something like:
+
+> Set up an OpenClaw cron that runs
+> `src/scanners/external/momentum/producer.mjs` every 5 minutes, with
+> wake now, in an isolated session, and capture output to a dedicated log
+> file named `external_momentum.log` for debugging.
+
+That request maps to these properties on the cron:
+
+- **Command:** `node /absolute/path/to/src/scanners/external/momentum/producer.mjs`
+  (export the same `SENPI_*` and `STRATEGY_ADDRESS` env vars the manual run uses).
+- **Interval:** every X minutes — pick a cadence that matches your
+  `TIMEFRAME` (e.g. `*/5 * * * *` for `1h` candles is plenty; tighten only
+  if you actually need faster reactions).
+- **Wake now:** trigger an immediate first run on creation so you don't
+  wait a full interval to confirm wiring.
+- **Isolated session:** each tick runs in its own session so a hung or
+  long-running invocation can't block the next one.
+- **Log capture:** redirect stdout/stderr to `<scanner-name>.log` (here:
+  `external_momentum.log`) so each run's accept/reject output and any
+  errors are inspectable after the fact.
+
+Verify by tailing the log after the first wake-now tick — you should see
+the same `accepted: true` / `signalCount` payload shown above. If signals
+aren't flowing, check the log first; producer rejections and missing env
+vars surface there.
+
+## Env
+
+| Var | Default | Purpose |
+|---|---|---|
+| `SENPI_API_KEY` | _required_ | Senpi MCP auth |
+| `SENPI_MCP_URL` | _required_ | Senpi MCP endpoint |
+| `STRATEGY_ADDRESS` | _required_ | Target wallet — must match the installed runtime |
+| `EXTERNAL_SCANNER_NAME` | `external_momentum` | Must match `scanners[].name` in the recipe |
+| `OPENCLAW_BIN` | `openclaw` | Path/name of the OpenClaw CLI binary |
+| `TIMEFRAME` | `1h` | Candle interval to evaluate |
+| `MIN_MOVE_PCT` | `1.5` | Minimum absolute % move to emit a signal |
+| `MIN_DAY_VOLUME` | `1000000` | Minimum 24h notional volume to consider an instrument |
+| `MIN_LEVERAGE` | `5` | Minimum max leverage for an instrument |
+| `MAX_CANDIDATES` | `20` | Top-N by volume to fetch candles for |
+| `MIN_SIGNAL_SCORE` | `0.2` | Drop signals below this normalized score |
+
+## Expected response
+
+```json
+{
+  "accepted": true,
+  "address": "0x...",
+  "scanner": "external_momentum",
+  "timestamp": 1775680200000,
+  "signalCount": 3,
+  "contextUpdated": false
+}
+```
+
+## Live test: force an OPEN_POSITION
+
+To verify the end-to-end entry path, loosen thresholds so almost any moving
+asset trips a signal, then let the LLM gauntlet in `momentum.yaml` decide:
+
+```bash
+MIN_MOVE_PCT=0.05 \
+MIN_SIGNAL_SCORE=0 \
+MIN_DAY_VOLUME=0 \
+node src/scanners/external/momentum/producer.mjs
+```
+
+Expect `accepted: true` with `signalCount >= 1`. In the runtime logs you
+should see `momentum_entry` firing, the LLM returning `execute: true` for
+the strongest-scoring eligible signal, and Senpi MCP opening the position.
+The DSL preset in `momentum.yaml` then takes over for trailing-exit
+management. Revert the env values before running unattended.
+
+## Manual e2e checklist
+
+- Happy path: live wallet, no strong movers → producer prints `0` signals
+  and skips the ingest.
+- Triggered path: a high-volume asset with a notable 1h move → producer
+  emits `MOMENTUM_BREAKOUT`; gateway returns `accepted: true` with matching
+  `signalCount`; runtime invokes the LLM action; position opens if the
+  gauntlet passes.
+- DSL handoff: after a fill, confirm `openclaw senpi position list` shows
+  the open position and that the DSL monitor is tracking it.
+- Unknown wallet: change `STRATEGY_ADDRESS` to a wallet without an installed
+  runtime → expect `NOT_FOUND`.
+- Disabled scanner: stop the runtime or rename the scanner in the recipe →
+  expect `INVALID_REQUEST`.
+- Schema rejection: edit `toExternalBatchItem` in `producer.mjs` to drop
+  `sourceMeta` → expect a validation `INVALID_REQUEST`.