@reefclaw/connect 0.1.10 → 0.1.12

package/assets/bridge/gateway/event-parser.d.ts

@@ -170,8 +170,13 @@ export interface ParsedEvent<E extends ProviderEventName = ProviderEventName> {
 export declare class EventParser {
     /** Buffered assistant text per runId, with timestamps for expiry */
     private assistantBuffers;
-    /** Last decision timestamp (set on lifecycle 'start') */
+    /** Last decision timestamp (set on lifecycle 'end' of a non-errored run) */
     private lastDecisionTs;
+    /** Runs that emitted a lifecycle 'error' — their 'end' must NOT count as a
+     *  decision. Issue #194: bumping on 'start' kept "last decision" fresh
+     *  through an 18h all-models-failed outage, so the dashboard's 2×-interval
+     *  "unresponsive" rung could never fire. Bounded (oldest evicted). */
+    private erroredRuns;
     /** Error timestamps within the rolling window */
     private errorTimestamps;
     /** Symbol for balance currency extraction */

package/assets/bridge/gateway/event-parser.js

@@ -417,8 +417,13 @@ const BUFFER_INACTIVITY_MS = 120_000; // 120 seconds — matches webapp streamin
 export class EventParser {
     /** Buffered assistant text per runId, with timestamps for expiry */
     assistantBuffers = new Map();
-    /** Last decision timestamp (set on lifecycle 'start') */
+    /** Last decision timestamp (set on lifecycle 'end' of a non-errored run) */
     lastDecisionTs = null;
+    /** Runs that emitted a lifecycle 'error' — their 'end' must NOT count as a
+     *  decision. Issue #194: bumping on 'start' kept "last decision" fresh
+     *  through an 18h all-models-failed outage, so the dashboard's 2×-interval
+     *  "unresponsive" rung could never fire. Bounded (oldest evicted). */
+    erroredRuns = new Set();
     /** Error timestamps within the rolling window */
     errorTimestamps = [];
     /** Symbol for balance currency extraction */
@@ -465,10 +470,15 @@ export class EventParser {
         }
         switch (phase) {
             case 'start':
-                this.lastDecisionTs = new Date().toISOString();
                 logger.debug(TAG, `Agent turn started: ${runId}`);
                 return [];
             case 'end': {
+                // A decision = a turn that ENDED without erroring. Bumping on 'start'
+                // (pre-#194) kept the timestamp fresh while every run failed, hiding
+                // an all-models-failed outage from the unresponsive heuristics.
+                if (!this.erroredRuns.delete(runId)) {
+                    this.lastDecisionTs = new Date().toISOString();
+                }
                 logger.debug(TAG, `Agent turn ended: ${runId}`);
                 return this.flushAssistantBuffer(runId);
             }
@@ -476,6 +486,13 @@ export class EventParser {
                 const errMsg = data.error ?? 'Unknown agent error';
                 logger.warn(TAG, `Agent error (run ${runId}): ${errMsg}`);
                 this.errorTimestamps.push(Date.now());
+                this.erroredRuns.add(runId);
+                // Bound the set: an errored run whose 'end' never arrives would leak.
+                if (this.erroredRuns.size > 100) {
+                    const oldest = this.erroredRuns.values().next().value;
+                    if (oldest !== undefined)
+                        this.erroredRuns.delete(oldest);
+                }
                 // Still flush the buffer — partial responses are better than nothing
                 return this.flushAssistantBuffer(runId);
             }

package/assets/bridge/gateway/heartbeat-cron.d.ts

@@ -0,0 +1,27 @@
+export declare const HEARTBEAT_CRON_NAME = "reefclaw-heartbeat";
+export declare const HEARTBEAT_EVERY_MS: number;
+export declare const HEARTBEAT_MESSAGE: string;
+export interface CronRpcClient {
+    sendRpc(method: string, params?: Record<string, unknown>): Promise<unknown>;
+}
+/**
+ * Whether an existing cron job counts as "the heartbeat already exists".
+ * Union of the two matchers already in the codebase: the old setup path
+ * matched /reefclaw/, while resolveHeartbeatSeconds() (the cadence reader that
+ * drives the dashboard header) matches /heart\s*beat/. A job satisfying either
+ * must suppress creation — prod/wisekid boxes carry heartbeat jobs whose names
+ * predate the reefclaw- prefix, and a duplicate 15m heartbeat would double the
+ * agent's token burn.
+ */
+export declare function isHeartbeatLikeName(name: unknown): boolean;
+export type EnsureHeartbeatOutcome = 'already_ensured' | 'found_existing' | 'created' | 'failed';
+/**
+ * Ensure a heartbeat cron exists. Non-fatal by contract: every failure path
+ * returns 'failed' rather than throwing, and only success writes the marker so
+ * a transient gateway error retries on the next boot.
+ */
+export declare function ensureHeartbeatCron(opts: {
+    rpc: CronRpcClient;
+    markerPath: string;
+    log: (msg: string) => void;
+}): Promise<EnsureHeartbeatOutcome>;

package/assets/bridge/gateway/heartbeat-cron.js

@@ -0,0 +1,85 @@
+// Ensures the ReefClaw heartbeat cron job exists — once per install — via
+// gateway RPC (`cron.list` / `cron.add`).
+//
+// This replaces the old setup-time shell-out to the openclaw CLI. The CLI's
+// cron commands are themselves gateway RPC clients, so shelling out bought
+// nothing except a subprocess + PATH dependency — and it ran at
+// setup time, when the gateway is typically NOT up yet (setup's printed next
+// step is "Start your OpenClaw agent"), which is why creation silently
+// no-op'd on fresh installs without a running gateway. The bridge holds an
+// authenticated gateway WS by construction, so the ensure runs there instead.
+//
+// Once-per-install semantics: a marker file records that the ensure has run to
+// completion. Without it, a user who deliberately deleted their heartbeat cron
+// would get it resurrected on every bridge boot — the old setup-time path ran
+// once, and that operator-override behaviour must be preserved.
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { dirname } from 'path';
+export const HEARTBEAT_CRON_NAME = 'reefclaw-heartbeat';
+export const HEARTBEAT_EVERY_MS = 15 * 60 * 1000;
+// Byte-identical to the message the setup-time CLI path created, so new jobs
+// match every existing install's job.
+export const HEARTBEAT_MESSAGE = 'Heartbeat. Run SESSION START mandatory checks, then the full Decision Loop (Steps 0-9) from SKILL.md. ' +
+    'Check tradingMode from fetch_balance — it is your source of truth for paper vs live. ' +
+    'Use tools in parallel where possible.';
+/**
+ * Whether an existing cron job counts as "the heartbeat already exists".
+ * Union of the two matchers already in the codebase: the old setup path
+ * matched /reefclaw/, while resolveHeartbeatSeconds() (the cadence reader that
+ * drives the dashboard header) matches /heart\s*beat/. A job satisfying either
+ * must suppress creation — prod/wisekid boxes carry heartbeat jobs whose names
+ * predate the reefclaw- prefix, and a duplicate 15m heartbeat would double the
+ * agent's token burn.
+ */
+export function isHeartbeatLikeName(name) {
+    return typeof name === 'string' && /reefclaw|heart\s*beat/i.test(name);
+}
+/**
+ * Ensure a heartbeat cron exists. Non-fatal by contract: every failure path
+ * returns 'failed' rather than throwing, and only success writes the marker so
+ * a transient gateway error retries on the next boot.
+ */
+export async function ensureHeartbeatCron(opts) {
+    const { rpc, markerPath, log } = opts;
+    try {
+        if (existsSync(markerPath))
+            return 'already_ensured';
+        // includeDisabled: a job the user disabled still means "exists" — re-adding
+        // a duplicate next to a deliberately-disabled one is worse than doing nothing.
+        const listResp = (await rpc.sendRpc('cron.list', { includeDisabled: true }));
+        const jobs = Array.isArray(listResp?.jobs) ? listResp.jobs : null;
+        if (!jobs) {
+            log('Heartbeat cron: skipped (cron.list returned no job list)');
+            return 'failed';
+        }
+        const existing = jobs.find((j) => isHeartbeatLikeName(j?.name));
+        if (existing) {
+            writeMarker(markerPath, { ensuredAt: new Date().toISOString(), found: String(existing.name) });
+            log(`Heartbeat cron: already exists (${String(existing.name)})`);
+            return 'found_existing';
+        }
+        // Parity with the params the CLI built for the old setup command
+        // (`openclaw cron add --name reefclaw-heartbeat --every 15m --session isolated --message ...`):
+        // isolated agentTurn defaults to delivery announce on the 'last' channel.
+        await rpc.sendRpc('cron.add', {
+            name: HEARTBEAT_CRON_NAME,
+            enabled: true,
+            schedule: { kind: 'every', everyMs: HEARTBEAT_EVERY_MS },
+            sessionTarget: 'isolated',
+            wakeMode: 'now',
+            payload: { kind: 'agentTurn', message: HEARTBEAT_MESSAGE },
+            delivery: { mode: 'announce', channel: 'last' },
+        });
+        writeMarker(markerPath, { ensuredAt: new Date().toISOString(), created: HEARTBEAT_CRON_NAME });
+        log(`Heartbeat cron: created (${HEARTBEAT_CRON_NAME}, every 15m)`);
+        return 'created';
+    }
+    catch (err) {
+        log(`Heartbeat cron: skipped (${err instanceof Error ? err.message.split('\n')[0] : String(err)})`);
+        return 'failed';
+    }
+}
+function writeMarker(markerPath, data) {
+    mkdirSync(dirname(markerPath), { recursive: true });
+    writeFileSync(markerPath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}

package/assets/bridge/gateway/poller.d.ts

@@ -4,6 +4,7 @@ import type { TickerData, CandleData, OrderData, MarketStructureData, CryptoMetr
 export declare const TICKER_INTERVAL_MS = 5000;
 export declare const OHLCV_INTERVAL_MS = 15000;
 export declare const POSITIONS_INTERVAL_MS = 10000;
+export declare const OPEN_ORDERS_INTERVAL_MS = 60000;
 export declare const MARKET_STRUCTURE_INTERVAL_MS = 60000;
 /** CCXT position — minimal shape needed by poller */
 export interface CcxtPosition {

package/assets/bridge/gateway/poller.js

@@ -25,7 +25,17 @@ export const OHLCV_INTERVAL_MS = 15_000;
 // startup handshake is extra live-system surface area for no extra weight.
 export const POSITIONS_INTERVAL_MS = 10_000;
 const BALANCE_INTERVAL_MS = 10_000;
-const OPEN_ORDERS_INTERVAL_MS = 3_000;
+// 2026-07-21: 3s → 60s, and the poll is now UNSCOPED (no symbol filter). Its
+// only consumer is the fallback cache behind Kill and the reconcile snapshot
+// (no event emission — live order updates ride the WS stream), and both of
+// those are portfolio-wide by contract: a { symbol }-scoped cache silently
+// degraded them to one symbol whenever the fresh all-symbol fetch failed.
+// Unscoped fetchOpenOrders costs Binance weight 80 (regular + algo merged) vs
+// 2 scoped, so the cadence drops to 60s (80/min, vs 40/min before; the old 3s
+// cadence unscoped would be 1600/min ≈ the whole ceiling). Matches the
+// plugin's own 60s algo-refresh; in userDataStream enforce mode the read is
+// served from the WS store at zero REST weight anyway.
+export const OPEN_ORDERS_INTERVAL_MS = 60_000;
 // 2026-05-15: 30s → 60s. get_market_structure fetches SIX timeframes of
 // OHLCV per poll (the heaviest single skill poll). Multi-timeframe trend
 // structure does not meaningfully change in 30s; 60s keeps the Agent-State
@@ -357,7 +367,9 @@ export class Poller {
     }
     async pollOpenOrders() {
         const tool = this.toolMap.fetch_open_orders;
-        const result = await this.http.invoke(tool, { symbol: this.symbol });
+        // Fetch ALL open orders (no symbol filter) — this cache is the fallback
+        // for the portfolio-wide Kill + reconcile snapshot (see interval comment).
+        const result = await this.http.invoke(tool, {});
         const orders = [];
         if (Array.isArray(result.data)) {
             for (const ccxt of result.data) {

package/assets/bridge/providers/gateway.d.ts

@@ -29,6 +29,8 @@ export declare class GatewayProvider implements OpenClawProvider {
     private agentIdentity;
     /** Emit the one-time rollout probe (gateway response shape) only on the first attempt. */
     private loggedAgentIdentityProbe;
+    /** One-shot latch for the boot-time heartbeat-cron ensure (re-armed on failure). */
+    private heartbeatCronEnsureStarted;
     /** Live heartbeat cadence (seconds), read from the OpenClaw cron store; cached 60s. */
     private heartbeatSeconds?;
     private heartbeatReadAtMs;
@@ -61,6 +63,18 @@ export declare class GatewayProvider implements OpenClawProvider {
     /** Track whether we've received at least one balance poll (needed for equity calculation). */
     private hasReceivedBalance;
     private readonly quoteCurrency;
+    /** issue #213 RED-zone debounce: consecutive RED evaluations + when the
+     *  streak began + when the position snapshot last refreshed. A RED verdict
+     *  must PERSIST and SURVIVE a positions refresh before auto-flatten fires —
+     *  in paper mode the wallet drops by FULL NOTIONAL at open, so a balance
+     *  poll landing before the new position reaches the snapshot reads the
+     *  entry's own notional as a phantom drawdown (observed live: a 38%-of-NAV
+     *  entry reported as a -38.41% RED zone 2s after its fill and was
+     *  auto-flattened). A race artifact cannot outlive one positions poll; a
+     *  real drawdown easily persists. */
+    private redZoneStreak;
+    private redZoneSince;
+    private positionsUpdatedAt;
     private orderTimestamps;
     private cancelTimestamps;
     private agentStateInterval;
@@ -301,8 +315,16 @@ export declare class GatewayProvider implements OpenClawProvider {
      */
     private reportTradeResult;
     /**
-     * Seed lastTradeTs from Intelligence API on startup. One-shot, best-effort.
-     * Prevents "Last Trade: Never" after every restart when the agent is flat.
+     * Seed lastTradeTs from the webapp's exchange-keyed fills ledger on startup.
+     * One-shot, best-effort. Prevents "Last Trade: Never" after every restart
+     * when the agent is flat.
+     *
+     * ★ Issue #194: the previous seed read intel's `trade_results` (closed
+     * round-trips only, single-symbol), which showed "last trade 365h ago"
+     * while the fills ledger had fills from the previous evening. The ledger
+     * (`GET /api/internal/trades`) is the source of truth for fills — seed from
+     * it, filtered to the current trading book. On any failure leave null:
+     * truthful-unknown beats confidently-wrong.
      */
     private seedLastTradeTs;
     /** Symbol formatted for intelligence API (BTC/USDT → BTCUSDT). */

package/assets/bridge/providers/gateway.js

@@ -11,16 +11,26 @@ import { GatewayWsClient } from '../gateway/gateway-ws-client.js';
 import { discoverTools } from '../gateway/tool-discovery.js';
 import { EventParser, mapCcxtBalance, mapCcxtOrder, extractLiquidationFields, extractBracketField, } from '../gateway/event-parser.js';
 import { Poller } from '../gateway/poller.js';
+import { ensureHeartbeatCron } from '../gateway/heartbeat-cron.js';
 import { computeEquity as _computeEquity, computePositionNotional as _computePositionNotional, computeRiskMetrics as _computeRiskMetrics, DEFAULT_RISK_LIMITS, } from './risk-calculator.js';
 import { executeKill as _executeKill, executeFlatten as _executeFlatten, executePause as _executePause, executeResume as _executeResume, } from './emergency-commands.js';
 import { executeSetTradingMode, executeGetBracketConfig, executeSetBracketRequirement, executeSetExchangeCredentials, executeTestExchangeCredentials, executeClearExchangeCredentials, } from './onboarding-commands.js';
 const TAG = 'gateway';
-// ---- Session NAV persistence ----
-// Persists sessionStartNav per date so Day P&L survives skill restarts.
-const SESSION_NAV_FILENAME = 'session-nav.json';
+// ---- Day-start NAV persistence ----
+// Persists sessionStartNav (the UTC-day P&L anchor) per date so Day P&L
+// survives skill restarts. The file was historically named session-nav.json;
+// renamed to day-start-nav.json 2026-07-22 — "session" was a misnomer (the
+// value anchors the trading DAY, not any auth/session state) and tripped
+// ClawHub's sensitive-file-read heuristic. Reads fall back to the legacy name
+// once, writes go to the new name only.
+const DAY_NAV_FILENAME = 'day-start-nav.json';
+const LEGACY_DAY_NAV_FILENAME = 'session-nav.json';
 const TRADING_MODE_FILENAME = 'trading-mode.json';
-function getSessionNavPath() {
-    return join(homedir(), '.openclaw', 'workspace', SESSION_NAV_FILENAME);
+function getDayNavPath() {
+    return join(homedir(), '.openclaw', 'workspace', DAY_NAV_FILENAME);
+}
+function getLegacyDayNavPath() {
+    return join(homedir(), '.openclaw', 'workspace', LEGACY_DAY_NAV_FILENAME);
 }
 function getTradingModePath() {
     return join(homedir(), '.openclaw', 'workspace', TRADING_MODE_FILENAME);
@@ -40,17 +50,20 @@ export function shouldAnchorSessionNav(args) {
     return args.mode === 'PAPER' && args.sessionDate !== args.today; // paper midnight rollover
 }
 function loadSessionStartNav() {
-    try {
-        const raw = readFileSync(getSessionNavPath(), 'utf-8');
-        const data = JSON.parse(raw);
-        if (data.date === todayDateStr() && typeof data.sessionStartNav === 'number' && data.sessionStartNav > 0) {
-            return data.sessionStartNav;
+    for (const path of [getDayNavPath(), getLegacyDayNavPath()]) {
+        try {
+            const raw = readFileSync(path, 'utf-8');
+            const data = JSON.parse(raw);
+            if (data.date === todayDateStr() && typeof data.sessionStartNav === 'number' && data.sessionStartNav > 0) {
+                return data.sessionStartNav;
+            }
+            return null; // Different day or invalid — don't let a stale legacy file shadow it
+        }
+        catch {
+            /* missing or corrupt — try the legacy name */
         }
-        return null; // Different day or invalid
-    }
-    catch {
-        return null; // File doesn't exist or is corrupt
     }
+    return null;
 }
 /**
  * Persisted across skill restarts so the FIRST snapshot the gateway emits
@@ -90,7 +103,11 @@ function saveSessionStartNav(nav) {
         const dir = join(homedir(), '.openclaw', 'workspace');
         mkdirSync(dir, { recursive: true });
         const data = { date: todayDateStr(), sessionStartNav: nav };
-        writeFileSync(getSessionNavPath(), JSON.stringify(data, null, 2), 'utf-8');
+        writeFileSync(getDayNavPath(), JSON.stringify(data, null, 2), 'utf-8');
+        try {
+            unlinkSync(getLegacyDayNavPath());
+        }
+        catch { /* legacy file already gone */ }
     }
     catch (err) {
         logger.warn(TAG, `Failed to save session NAV: ${err instanceof Error ? err.message : String(err)}`);
@@ -122,6 +139,8 @@ export class GatewayProvider {
     agentIdentity = {};
     /** Emit the one-time rollout probe (gateway response shape) only on the first attempt. */
     loggedAgentIdentityProbe = false;
+    /** One-shot latch for the boot-time heartbeat-cron ensure (re-armed on failure). */
+    heartbeatCronEnsureStarted = false;
     /** Live heartbeat cadence (seconds), read from the OpenClaw cron store; cached 60s. */
     heartbeatSeconds;
     heartbeatReadAtMs = 0;
@@ -154,6 +173,18 @@ export class GatewayProvider {
     /** Track whether we've received at least one balance poll (needed for equity calculation). */
     hasReceivedBalance = false;
     quoteCurrency;
+    /** issue #213 RED-zone debounce: consecutive RED evaluations + when the
+     *  streak began + when the position snapshot last refreshed. A RED verdict
+     *  must PERSIST and SURVIVE a positions refresh before auto-flatten fires —
+     *  in paper mode the wallet drops by FULL NOTIONAL at open, so a balance
+     *  poll landing before the new position reaches the snapshot reads the
+     *  entry's own notional as a phantom drawdown (observed live: a 38%-of-NAV
+     *  entry reported as a -38.41% RED zone 2s after its fill and was
+     *  auto-flattened). A race artifact cannot outlive one positions poll; a
+     *  real drawdown easily persists. */
+    redZoneStreak = 0;
+    redZoneSince = 0;
+    positionsUpdatedAt = 0;
     // ---- Rate tracking ----
     orderTimestamps = [];
     cancelTimestamps = [];
@@ -658,6 +689,7 @@ export class GatewayProvider {
         }
         // Update internal state with fresh data (poller may be paused during reconnect)
         this.positions = positions;
+        this.positionsUpdatedAt = Date.now();
         this.balance = balance;
         this.openOrders = openOrders;
         // Compute current NAV for portfolio percent calculation (consistent with computeRiskMetrics)
@@ -1057,6 +1089,24 @@ export class GatewayProvider {
         // every (re)connect so a model swap — which restarts the gateway and drops
         // this socket — is reflected on the next handshake.
         void this.refreshAgentIdentity();
+        // Ensure the heartbeat cron exists — via gateway RPC, once per install
+        // (marker-file guarded; a deliberate operator delete is never resurrected).
+        // Lives here instead of setup because setup runs before the gateway is up.
+        if (!this.heartbeatCronEnsureStarted) {
+            this.heartbeatCronEnsureStarted = true;
+            const ws = this.wsClient;
+            if (ws) {
+                void ensureHeartbeatCron({
+                    rpc: ws,
+                    markerPath: join(homedir(), '.openclaw', 'workspace', 'heartbeat-cron-ensured.json'),
+                    log: (msg) => logger.info(TAG, msg),
+                }).then((outcome) => {
+                    // A transient failure retries on the next (re)connect, not just next boot.
+                    if (outcome === 'failed')
+                        this.heartbeatCronEnsureStarted = false;
+                });
+            }
+        }
         // Start periodic agent state emission (every 5s)
         if (!this.agentStateInterval) {
             this.agentStateInterval = setInterval(() => {
@@ -1201,6 +1251,7 @@ export class GatewayProvider {
             }
         }
         this.positions = positions;
+        this.positionsUpdatedAt = Date.now();
         this.hasReceivedPositions = true;
         this.trySetSessionStartNav();
         this.emitRiskUpdate();
@@ -1575,7 +1626,11 @@ export class GatewayProvider {
                     this.hasReceivedPositions = false;
                     this.pendingEmptyPoll = false;
                     try {
-                        unlinkSync(getSessionNavPath());
+                        unlinkSync(getDayNavPath());
+                    }
+                    catch { /* ok if missing */ }
+                    try {
+                        unlinkSync(getLegacyDayNavPath());
                     }
                     catch { /* ok if missing */ }
                     logger.info(TAG, `Session start NAV reset on mode change (${prevMode} → ${this.tradingMode})`);
@@ -1890,10 +1945,32 @@ export class GatewayProvider {
         //     physically impossible under normal market conditions on a bracketed
         //     account. If the math says worse than that, it's bad data — log loudly
         //     and skip instead of closing real positions on a calculation error.
+        //  4. Persistence debounce (issue #213): the balance poll and the position
+        //     snapshot are not atomic. In PAPER mode the simulator deducts FULL
+        //     NOTIONAL from the wallet at open, so in the seconds after a fill the
+        //     wallet already reflects the deduction while `this.positions` does not
+        //     yet contain the new position — equity spuriously drops by exactly the
+        //     entry's notional and any entry >2.5% of NAV reads as a RED drawdown
+        //     (observed live: -38.41% reported 2s after a 38%-of-NAV entry; the
+        //     just-opened position was auto-flattened). A RED verdict therefore
+        //     only licenses the flatten once it (a) persists across REQUIRED_STREAK
+        //     consecutive evaluations, (b) has been standing MIN_RED_PERSISTENCE_MS,
+        //     and (c) has SURVIVED at least one positions refresh since it began —
+        //     the race artifact cannot outlive one positions poll (~10s), while a
+        //     real -2.5% drawdown trivially persists 25s. Cost on a real event:
+        //     the flatten fires ~25-35s later. Cost of a false one: a closed
+        //     position, a rejected-orders window, and a corrupted trading record.
         const uptimeMs = Date.now() - this.startedAt;
         const STARTUP_GRACE_PERIOD_MS = 30_000;
         const IMPOSSIBLE_DRAWDOWN = -0.5;
+        const REQUIRED_RED_STREAK = 3;
+        const MIN_RED_PERSISTENCE_MS = 25_000;
         if (metrics.drawdownZone === 'RED' && this.agentMode === 'ACTIVE') {
+            if (this.redZoneStreak === 0)
+                this.redZoneSince = Date.now();
+            this.redZoneStreak++;
+            const redForMs = Date.now() - this.redZoneSince;
+            const survivedPositionsRefresh = this.positionsUpdatedAt > this.redZoneSince;
             if (uptimeMs < STARTUP_GRACE_PERIOD_MS) {
                 logger.warn(TAG, `RED zone drawdown detected (${metrics.drawdownZoneMessage}) but within startup grace period (${Math.round(uptimeMs / 1000)}s) — skipping auto-flatten`);
             }
@@ -1903,6 +1980,11 @@ export class GatewayProvider {
             else if (metrics.utilization.dailyDrawdown < IMPOSSIBLE_DRAWDOWN) {
                 logger.error(TAG, `RED zone drawdown ${(metrics.utilization.dailyDrawdown * 100).toFixed(1)}% exceeds sanity floor ${IMPOSSIBLE_DRAWDOWN * 100}% — refusing auto-flatten, likely equity calculation error (balance.total=${this.balance.total}, sessionStartNav=${this.sessionStartNav}, positions=${this.positions.length})`);
             }
+            else if (this.redZoneStreak < REQUIRED_RED_STREAK ||
+                redForMs < MIN_RED_PERSISTENCE_MS ||
+                !survivedPositionsRefresh) {
+                logger.warn(TAG, `RED zone drawdown detected (${metrics.drawdownZoneMessage}) — deferring auto-flatten until the verdict persists (streak ${this.redZoneStreak}/${REQUIRED_RED_STREAK}, ${Math.round(redForMs / 1000)}s/${MIN_RED_PERSISTENCE_MS / 1000}s, survivedPositionsRefresh=${survivedPositionsRefresh}). A fresh entry's notional reads as phantom drawdown until the position snapshot catches up (issue #213); a real drawdown will persist and flatten on a later evaluation.`);
+            }
             else {
                 logger.warn(TAG, `RED zone drawdown detected (${metrics.drawdownZoneMessage}) — auto-flattening all positions`);
                 // Route through executeEmergency (NOT executeFlatten directly) so the
@@ -1917,6 +1999,11 @@ export class GatewayProvider {
                 });
             }
         }
+        else {
+            // Any non-RED evaluation clears the streak — the race artifact resolves
+            // the moment the positions snapshot includes the new position.
+            this.redZoneStreak = 0;
+        }
         // Include position snapshots + balance in risk_update so the webapp can
         // update KPI/PnL without depending on market_data ticker events.
         const equity = this.computeEquity();
@@ -2097,27 +2184,39 @@ export class GatewayProvider {
         this.inFlightReports.push(report);
     }
     /**
-     * Seed lastTradeTs from Intelligence API on startup. One-shot, best-effort.
-     * Prevents "Last Trade: Never" after every restart when the agent is flat.
+     * Seed lastTradeTs from the webapp's exchange-keyed fills ledger on startup.
+     * One-shot, best-effort. Prevents "Last Trade: Never" after every restart
+     * when the agent is flat.
+     *
+     * ★ Issue #194: the previous seed read intel's `trade_results` (closed
+     * round-trips only, single-symbol), which showed "last trade 365h ago"
+     * while the fills ledger had fills from the previous evening. The ledger
+     * (`GET /api/internal/trades`) is the source of truth for fills — seed from
+     * it, filtered to the current trading book. On any failure leave null:
+     * truthful-unknown beats confidently-wrong.
      */
     async seedLastTradeTs() {
         if (this.lastTradeTs)
             return; // Already set (e.g. from WS event during init)
-        const url = this.config.intelligenceUrl;
         const token = this.config.connectionToken;
-        if (!url || !token)
+        if (!token)
             return;
+        // www is load-bearing: reefclaw.com 307-redirects and Node fetch strips
+        // the Authorization header on cross-origin redirect (same as bridge.ts).
+        const base = (process.env.REEFCLAW_API_URL || 'https://www.reefclaw.com').replace(/\/$/, '');
+        const mode = this.tradingMode === 'PAPER' ? 'paper' : 'live';
         try {
-            const res = await fetch(`${url}/api/analytics/${this.config.symbol.replace('/', '')}/trades?limit=1`, {
+            const res = await fetch(`${base}/api/internal/trades?limit=1&mode=${mode}`, {
                 headers: { Authorization: `Bearer ${token}` },
                 signal: AbortSignal.timeout(5_000),
             });
             if (!res.ok)
                 return;
-            const trades = await res.json();
-            if (trades.length > 0 && trades[0].timestamp) {
-                this.lastTradeTs = trades[0].timestamp;
-                logger.info(TAG, `Seeded lastTradeTs from Intelligence: ${this.lastTradeTs}`);
+            const body = (await res.json());
+            const ts = body.trades?.[0]?.fillTimestamp;
+            if (ts) {
+                this.lastTradeTs = ts;
+                logger.info(TAG, `Seeded lastTradeTs from trades ledger (${mode}): ${this.lastTradeTs}`);
                 this.emitAgentState(); // Re-emit with updated timestamp
             }
         }

package/assets/bridge/setup.js

@@ -1,7 +1,6 @@
 // Interactive setup helper for the ReefClaw skill.
 // Validates token format, tests relay connection, saves to OpenClaw config.
 import WebSocket from 'ws';
-import { execSync } from 'node:child_process';
 import { writeOpenClawConfig } from './config.js';
 import { logger } from './logger.js';
 const TAG = 'setup';
@@ -149,8 +148,12 @@ export async function runSetup(tokenOrBundle, userId, relayUrl) {
     }
     // Save to config
     writeOpenClawConfig(token, resolvedUserId, resolvedRelayUrl);
-    // Create heartbeat cron job if none exists
-    ensureHeartbeatCron();
+    // Heartbeat cron is ensured by the bridge at first gateway connect (via
+    // cron.list/cron.add RPC — see gateway/heartbeat-cron.ts). Setup can't do it:
+    // the gateway isn't running yet at this point, which is also why the old
+    // setup-time shell-out to the openclaw CLI silently no-op'd on fresh
+    // installs (the CLI's cron commands are gateway RPC clients too).
+    console.log('  Heartbeat cron: created automatically when the agent first connects (every 15m)');
     console.log('');
     console.log('  Setup complete! Token saved to ~/.openclaw/config.json');
     console.log('');
@@ -161,54 +164,6 @@ export async function runSetup(tokenOrBundle, userId, relayUrl) {
     console.log('    4. Your agent checks the market every 15 minutes (adjustable via chat)');
     console.log('');
 }
-// ---- Heartbeat cron ----
-/**
- * Ensures a heartbeat cron job exists for ReefClaw.
- * Checks `openclaw cron list` for an existing job with "reefclaw" in the name.
- * If none found, creates one with 15m default interval.
- * Non-fatal — if openclaw CLI isn't available or cron fails, setup still succeeds.
- */
-function ensureHeartbeatCron() {
-    try {
-        // Check if a reefclaw cron already exists
-        const listOutput = execSync('openclaw cron list --json 2>/dev/null', {
-            encoding: 'utf-8',
-            timeout: 15_000,
-        });
-        // Look for any job with "reefclaw" in the name
-        try {
-            const jobs = JSON.parse(listOutput);
-            const existing = (Array.isArray(jobs) ? jobs : []).find((j) => j.name?.toLowerCase().includes('reefclaw'));
-            if (existing) {
-                console.log(`  Heartbeat cron: already exists (${existing.name})`);
-                return;
-            }
-        }
-        catch {
-            // JSON parse failed — maybe not JSON output, check raw text
-            if (listOutput.toLowerCase().includes('reefclaw')) {
-                console.log('  Heartbeat cron: already exists');
-                return;
-            }
-        }
-        // No existing job — create one
-        console.log('  Creating heartbeat cron (every 15m)...');
-        execSync('openclaw cron add --name reefclaw-heartbeat --every 15m --session isolated ' +
-            "--message 'Heartbeat. Run SESSION START mandatory checks, then the full Decision Loop (Steps 0-9) from SKILL.md. Check tradingMode from fetch_balance — it is your source of truth for paper vs live. Use tools in parallel where possible.' 2>&1", { encoding: 'utf-8', timeout: 15_000 });
-        console.log('  Heartbeat cron: created (every 15 minutes)');
-        console.log('  Tip: Ask your agent "change heartbeat to 10 minutes" to adjust');
-    }
-    catch (err) {
-        // Non-fatal — user can create cron manually or agent can create it on first session
-        const msg = err instanceof Error ? err.message : String(err);
-        if (msg.includes('not found') || msg.includes('ENOENT')) {
-            console.log('  Heartbeat cron: skipped (openclaw CLI not in PATH)');
-        }
-        else {
-            console.log(`  Heartbeat cron: skipped (${msg.split('\n')[0]})`);
-        }
-    }
-}
 function printSetupInstructions() {
     console.log('  To connect your OpenClaw agent to ReefClaw:');
     console.log('');

package/assets/shared/signals/conditions/registry.js

@@ -153,11 +153,20 @@ register('price_sweep', (ctx, params, _dir, condCtx) => {
             sweepLevel = nearestHigh;
         }
     }
-    // Store in shared context for entry/stop rules and direction
+    // Store in shared context for entry/stop rules and direction.
+    // sweptDirection is written non-destructively, like the funding_extreme /
+    // cvd_divergence setters: only when a sweep actually resolved a side. An
+    // unconditional write (including null on a no-sweep bar) clobbered a
+    // direction set by an earlier condition in the same evaluation, so a
+    // from_sweep/from_funding strategy listing price_sweep AFTER another
+    // setter could never fire.
     condCtx.sweepLevel = sweepLevel;
     condCtx.recentLow = recentLow;
     condCtx.recentHigh = recentHigh;
-    condCtx.sweptDirection = sweptLow ? 'LONG' : sweptHigh ? 'SHORT' : null;
+    if (sweptLow)
+        condCtx.sweptDirection = 'LONG';
+    else if (sweptHigh)
+        condCtx.sweptDirection = 'SHORT';
     const met = sweptLow || sweptHigh;
     return {
         met,