solana-traderclaw 1.0.99 → 1.0.101

package/README.md

@@ -113,6 +113,8 @@ Run mandatory startup sequence and report pass/fail for each:
 6) solana_killswitch_status
 ```
 
+If alpha signals stop but the gateway looks healthy, call `solana_alpha_subscribe({ force: true })` or inspect `solana_runtime_status` (alpha `stats.lastEventTs`, `subscribed`). The plugin also runs a background watchdog for stale ingestion and gateway forward probes.
+
 ### Non-interactive setup
 
 ```bash
@@ -379,7 +381,7 @@ Pay-as-you-go or Basic tier is required for the read-only social intel tools.
 ### Alpha Signal Processing
 | Tool | Description |
 |------|-------------|
-| `solana_alpha_subscribe` | Subscribe to alpha signal WebSocket feed |
+| `solana_alpha_subscribe` | Subscribe to alpha WebSocket feed (`force: true` reconnects if ingestion stalls) |
 | `solana_alpha_unsubscribe` | Unsubscribe from alpha feed |
 | `solana_alpha_signals` | Retrieve buffered alpha signals |
 | `solana_alpha_history` | Query historical alpha signals |
@@ -413,7 +415,7 @@ Pay-as-you-go or Basic tier is required for the read-only social intel tools.
 | `solana_gateway_forward_probe` | Probe gateway forwarding connectivity |
 | `solana_agent_sessions` | View agent session diagnostics |
 | `solana_startup_gate` | Run startup gate sequence |
-| `solana_runtime_status` | Get runtime status diagnostics |
+| `solana_runtime_status` | Runtime diagnostics (startup gate, alpha stats / `lastEventTs`, last forward probe) |
 
 ### Local Durable State
 | Tool | Description |

package/dist/{chunk-ATWB7K63.js → chunk-JVQNXWBW.js}

@@ -2,6 +2,8 @@
 var RECONNECT_DELAYS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
 var PING_INTERVAL_MS = 3e4;
 var PONG_TIMEOUT_MS = 1e4;
+var ALPHA_INGESTION_STALE_MS = 20 * 60 * 1e3;
+var ALPHA_STALE_GRACE_AFTER_CONNECT_MS = 3 * 60 * 1e3;
 var AlphaStreamManager = class {
   config;
   ws = null;
@@ -19,10 +21,50 @@ var AlphaStreamManager = class {
   constructor(config) {
     this.config = config;
   }
-  async subscribe() {
-    if (this.subscribed && this.ws && this.ws.readyState === 1) {
+  /**
+   * @param opts.force If true, drop the existing WebSocket (when connected) and subscribe again.
+   * Use when the socket looks healthy but alpha_signal delivery may have stalled.
+   */
+  async subscribe(opts = {}) {
+    const force = Boolean(opts.force);
+    if (!force && this.subscribed && this.ws && this.ws.readyState === 1) {
       return { subscribed: true, premiumAccess: this.premiumAccess, tier: this.tier };
     }
+    if (force && this.ws) {
+      if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+      }
+      const oldWs = this.ws;
+      this.intentionalClose = true;
+      this.log("info", "Force subscribe: closing WebSocket for clean reconnect");
+      await new Promise((resolve) => {
+        if (oldWs.readyState === 3) {
+          resolve();
+          return;
+        }
+        const t = setTimeout(resolve, 5e3);
+        oldWs.once("close", () => {
+          clearTimeout(t);
+          resolve();
+        });
+        try {
+          if (oldWs.readyState === 1 || oldWs.readyState === 0) {
+            oldWs.close();
+          } else {
+            clearTimeout(t);
+            resolve();
+          }
+        } catch {
+          clearTimeout(t);
+          resolve();
+        }
+      });
+      this.ws = null;
+      this.subscribed = false;
+      this.authenticated = false;
+      this.intentionalClose = false;
+    }
     this.intentionalClose = false;
     await this.connect();
     return new Promise((resolve, reject) => {
@@ -39,6 +81,26 @@ var AlphaStreamManager = class {
       }, 15e3);
     });
   }
+  /**
+   * True when the socket reports subscribed but no alpha_signal has been received for
+   * {@link ALPHA_INGESTION_STALE_MS} (after {@link ALPHA_STALE_GRACE_AFTER_CONNECT_MS}).
+   */
+  isIngestionStale(now = Date.now()) {
+    if (!this.isSubscribed()) return false;
+    const uptime = now - this.connectedAt;
+    if (uptime < ALPHA_STALE_GRACE_AFTER_CONNECT_MS) return false;
+    const lastActivity = this.lastEventTs > 0 ? this.lastEventTs : this.connectedAt;
+    return now - lastActivity >= ALPHA_INGESTION_STALE_MS;
+  }
+  /**
+   * Re-send alpha_stream_subscribe on the existing connection (soft recovery).
+   * @returns true if the message was sent
+   */
+  resendApplicationSubscribe() {
+    if (!this.authenticated || !this.ws || this.ws.readyState !== 1) return false;
+    this.sendAlphaSubscribe();
+    return true;
+  }
   async unsubscribe() {
     this.intentionalClose = true;
     this.subscribed = false;
@@ -266,5 +328,7 @@ var AlphaStreamManager = class {
 };
 
 export {
+  ALPHA_INGESTION_STALE_MS,
+  ALPHA_STALE_GRACE_AFTER_CONNECT_MS,
   AlphaStreamManager
 };

package/dist/chunk-R24UDHQG.js

@@ -0,0 +1,21 @@
+// src/gateway-config-sync.ts
+function normalizeGatewayBaseUrl(url) {
+  return String(url || "").trim().replace(/\/+$/, "");
+}
+function shouldSyncGatewayCredentials(localBaseUrl, localToken, active) {
+  const gbu = String(localBaseUrl || "").trim();
+  const gt = String(localToken || "").trim();
+  if (!gbu || !gt || !active) return false;
+  const lUrl = normalizeGatewayBaseUrl(gbu);
+  const rUrl = normalizeGatewayBaseUrl(String(active.gatewayBaseUrl ?? ""));
+  if (lUrl !== rUrl) return true;
+  if (typeof active.gatewayToken === "string") {
+    return active.gatewayToken.trim() !== gt;
+  }
+  return false;
+}
+
+export {
+  normalizeGatewayBaseUrl,
+  shouldSyncGatewayCredentials
+};

package/dist/index.js

@@ -1,3 +1,6 @@
+import {
+  readRecoverySecretFromDisk
+} from "./chunk-SBYHSJLU.js";
 import {
   SessionManager
 } from "./chunk-VVEKPKW3.js";
@@ -15,10 +18,13 @@ import {
 } from "./chunk-3UQIQJPQ.js";
 import {
   AlphaStreamManager
-} from "./chunk-ATWB7K63.js";
+} from "./chunk-JVQNXWBW.js";
 import {
   BitqueryStreamManager
 } from "./chunk-S2DLZKMQ.js";
+import {
+  shouldSyncGatewayCredentials
+} from "./chunk-R24UDHQG.js";
 import {
   orchestratorRequest
 } from "./chunk-6GSGHMUH.js";
@@ -35,9 +41,6 @@ import {
 import {
   scrubUntrustedText
 } from "./chunk-AI6MTHUN.js";
-import {
-  readRecoverySecretFromDisk
-} from "./chunk-SBYHSJLU.js";
 
 // index.ts
 import { Type } from "@sinclair/typebox";
@@ -2593,6 +2596,18 @@ ${notes}
             refreshed = await get("/api/agents/gateway-credentials");
             activeCredential = getActiveCredential(refreshed);
           }
+          if (activeCredential && autoFixGateway && gbu && gt && shouldSyncGatewayCredentials(gbu, gt, activeCredential)) {
+            const driftBody = {
+              gatewayBaseUrl: gbu,
+              gatewayToken: gt,
+              active: true
+            };
+            if (config.agentId) driftBody.agentId = config.agentId;
+            if (forwardChatId) driftBody.forwardTelegramChatId = forwardChatId;
+            await put("/api/agents/gateway-credentials", driftBody);
+            refreshed = await get("/api/agents/gateway-credentials");
+            activeCredential = getActiveCredential(refreshed);
+          }
           gatewayStepOk = Boolean(activeCredential);
           if (!gatewayStepOk) throw new Error("Gateway credentials are missing or inactive");
           pushStep({
@@ -2697,10 +2712,13 @@ ${notes}
     };
     api.registerTool({
       name: "solana_alpha_subscribe",
-      description: "Subscribe to the SpyFly alpha signal stream via WebSocket. Signals are buffered locally and retrieved with solana_alpha_signals. The startup gate calls this automatically. Optionally set agentId and subscriberType for event-to-agent forwarding.",
+      description: "Subscribe to the SpyFly alpha signal stream via WebSocket. Signals are buffered locally and retrieved with solana_alpha_signals. The startup gate calls this automatically. Optionally set agentId and subscriberType for event-to-agent forwarding. Use force=true to close an existing connection and resubscribe when the socket looks healthy but alpha_signal ingestion has stalled (zombie subscription).",
       parameters: Type.Object({
         agentId: Type.Optional(Type.String({ description: "Agent ID for event-to-agent forwarding. Uses plugin config agentId as default." })),
-        subscriberType: Type.Optional(Type.String({ description: "Subscriber type: 'agent' or 'client'." }))
+        subscriberType: Type.Optional(Type.String({ description: "Subscriber type: 'agent' or 'client'." })),
+        force: Type.Optional(Type.Boolean({
+          description: "If true, disconnect any existing WebSocket and subscribe again. Use when resubscribe would otherwise be a no-op but signals stopped arriving."
+        }))
       }),
       execute: wrapExecute("solana_alpha_subscribe", async (_id, params) => {
         const effectiveAgentId = params.agentId || config.agentId;
@@ -2711,7 +2729,7 @@ ${notes}
         if (effectiveSubscriberType) {
           alphaStreamManager.setSubscriberType(effectiveSubscriberType);
         }
-        return alphaStreamManager.subscribe();
+        return alphaStreamManager.subscribe({ force: params.force === true });
       })
     });
     api.registerTool({
@@ -2923,6 +2941,7 @@ ${notes}
         startupGate: startupGateState,
         alphaStream: {
           subscribed: alphaStreamManager.isSubscribed(),
+          ingestionStale: alphaStreamManager.isIngestionStale(),
           stats: alphaStreamManager.getStats(),
           bufferSize: alphaBuffer.getBufferSize()
         },
@@ -4285,8 +4304,16 @@ Context compaction triggered. STATE.md synced from last persisted state. Decisio
           api.logger.warn(`[solana-trader] Forward probe failed: ${err instanceof Error ? err.message : String(err)}`);
         }
         const WATCHDOG_INTERVAL_MS = 9e4;
+        const FORWARD_PROBE_WATCHDOG_MS = 7 * 60 * 1e3;
+        const STARTUP_GATE_AFTER_PROBE_FAIL_COOLDOWN_MS = 10 * 60 * 1e3;
+        let alphaStalePhase = 0;
+        const watchdogStartedAt = Date.now();
+        let lastForwardProbeWatchdogMs = watchdogStartedAt;
+        let lastProbeFailureStartupGateMs = watchdogStartedAt;
         const watchdogTimer = setInterval(async () => {
+          const now = Date.now();
           if (!alphaStreamManager.isSubscribed()) {
+            alphaStalePhase = 0;
             api.logger.warn("[watchdog] Alpha stream not subscribed \u2014 resubscribing...");
             try {
               await alphaStreamManager.subscribe();
@@ -4294,6 +4321,32 @@ Context compaction triggered. STATE.md synced from last persisted state. Decisio
             } catch (err) {
               api.logger.error(`[watchdog] Alpha resubscribe failed: ${err instanceof Error ? err.message : String(err)}`);
             }
+          } else if (alphaStreamManager.isIngestionStale(now)) {
+            if (alphaStalePhase === 0) {
+              api.logger.warn("[watchdog] Alpha ingestion stale (no recent alpha_signal) \u2014 resending alpha_stream_subscribe");
+              if (alphaStreamManager.resendApplicationSubscribe()) {
+                alphaStalePhase = 1;
+              } else {
+                try {
+                  await alphaStreamManager.subscribe({ force: true });
+                  api.logger.info("[watchdog] Alpha force-resubscribe completed (soft send unavailable).");
+                } catch (err) {
+                  api.logger.error(`[watchdog] Alpha force-resubscribe failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                alphaStalePhase = 0;
+              }
+            } else {
+              api.logger.warn("[watchdog] Alpha still stale after soft recovery \u2014 forcing WebSocket reconnect");
+              try {
+                await alphaStreamManager.subscribe({ force: true });
+                api.logger.info("[watchdog] Alpha force-resubscribe completed.");
+              } catch (err) {
+                api.logger.error(`[watchdog] Alpha force-resubscribe failed: ${err instanceof Error ? err.message : String(err)}`);
+              }
+              alphaStalePhase = 0;
+            }
+          } else {
+            alphaStalePhase = 0;
           }
           try {
             const creds = await get("/api/agents/gateway-credentials");
@@ -4304,6 +4357,22 @@ Context compaction triggered. STATE.md synced from last persisted state. Decisio
           } catch (err) {
             api.logger.warn(`[watchdog] Gateway credential check failed: ${err instanceof Error ? err.message : String(err)}`);
           }
+          if (now - lastForwardProbeWatchdogMs >= FORWARD_PROBE_WATCHDOG_MS) {
+            lastForwardProbeWatchdogMs = now;
+            try {
+              const pr = await runForwardProbe({ agentId: config.agentId || "main", source: "watchdog" });
+              if (!Boolean(pr.ok)) {
+                api.logger.warn(`[watchdog] Gateway forward probe failed: ${JSON.stringify(pr)}`);
+                if (now - lastProbeFailureStartupGateMs >= STARTUP_GATE_AFTER_PROBE_FAIL_COOLDOWN_MS) {
+                  lastProbeFailureStartupGateMs = now;
+                  api.logger.warn("[watchdog] Running startup gate after forward probe failure (cooldown elapsed)");
+                  await runStartupGate({ autoFixGateway: true, force: true });
+                }
+              }
+            } catch (err) {
+              api.logger.warn(`[watchdog] Forward probe error: ${err instanceof Error ? err.message : String(err)}`);
+            }
+          }
         }, WATCHDOG_INTERVAL_MS);
         if (watchdogTimer && typeof watchdogTimer === "object" && "unref" in watchdogTimer) {
           watchdogTimer.unref();

package/dist/src/alpha-ws.js

@@ -1,6 +1,10 @@
 import {
+  ALPHA_INGESTION_STALE_MS,
+  ALPHA_STALE_GRACE_AFTER_CONNECT_MS,
   AlphaStreamManager
-} from "../chunk-ATWB7K63.js";
+} from "../chunk-JVQNXWBW.js";
 export {
+  ALPHA_INGESTION_STALE_MS,
+  ALPHA_STALE_GRACE_AFTER_CONNECT_MS,
   AlphaStreamManager
 };

package/dist/src/gateway-config-sync.js

@@ -0,0 +1,8 @@
+import {
+  normalizeGatewayBaseUrl,
+  shouldSyncGatewayCredentials
+} from "../chunk-R24UDHQG.js";
+export {
+  normalizeGatewayBaseUrl,
+  shouldSyncGatewayCredentials
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solana-traderclaw",
-  "version": "1.0.99",
+  "version": "1.0.101",
   "description": "TraderClaw V1-Upgraded — Solana trading for OpenClaw with intelligence lab, tool envelopes, prompt scrubbing, read-only X social intel, and split skill docs",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,6 +17,7 @@
   ],
   "scripts": {
     "build": "node build.mjs",
+    "test": "npm run build && node scripts/gateway-config-sync-selftest.mjs",
     "prepublishOnly": "npm run build",
     "sync-cli": "node scripts/sync-cli-version.mjs",
     "release:patch": "node scripts/release-patch.mjs"

package/skills/solana-trader/HEARTBEAT.md

@@ -60,7 +60,7 @@ Call `solana_scan_launches` for new launches and `solana_scan_hot_pairs` for hot
 
 ## STEP 1.5: ALPHA SIGNALS
 
-Call `solana_alpha_signals` to poll the buffer. Score and classify each signal by priority. Check `calledAgainCount` — multiple independent callers on same token = high conviction.
+Call `solana_alpha_signals` to poll the buffer. Score and classify each signal by priority. Check `calledAgainCount` — multiple independent callers on same token = high conviction. If buffer stays empty while live, `solana_runtime_status` then `solana_alpha_subscribe({ force: true })` or unsub+subscribe.
 
 **Source trust check (mandatory before acting on any signal):**
 ```

package/skills/solana-trader/SKILL.md

@@ -162,7 +162,7 @@ After startup completes, deliver the welcome ceremony:
 
 1. `solana_system_status()` — verify orchestrator reachable
 2. `solana_gateway_credentials_get()` — verify gateway registered
-3. `solana_alpha_subscribe({ agentId: "main" })` — start signal stream
+3. `solana_alpha_subscribe({ agentId: "main" })` — start signal stream (`force: true` if the socket looks live but alpha ingestion stalled)
 4. `solana_capital_status()` + `solana_positions()` + `solana_killswitch_status()` — portfolio health
 5. `solana_gateway_forward_probe({ agentId: "main" })` — verify wake path
 

package/skills/solana-trader/workspace/TOOLS.md

@@ -101,7 +101,7 @@ Every tool has a mandatory trigger — when the trigger condition is met, you MU
 ### Alpha Signals (5)
 | Tool | Purpose | When to Call |
 |---|---|---|
-| `solana_alpha_subscribe` | Subscribe to alpha stream | Startup sequence; when stream disconnects |
+| `solana_alpha_subscribe` | Subscribe to alpha stream (`force: true` forces reconnect) | Startup sequence; when stream disconnects or ingestion stalls |
 | `solana_alpha_signals` | Poll buffered signals | Step 1.5 every heartbeat |
 | `solana_alpha_history` | Historical signal data | Step 1.5 to check prior calls on a token; Step 7 to check source accuracy after exit |
 | `solana_alpha_sources` | Per-source performance stats | Step 1.5 to check source win rates; `source_reputation_recalc` cron |