@reefclaw/openclaw-plugin 0.1.23 → 0.1.24

package/tools/get-market-intel.js

@@ -12,6 +12,7 @@
 // unchanged. This bounds the threat — it can't make the agent place a naked
 // order (the create_order gate still applies) — and makes injected directives
 // far less likely to be followed.
+import { keepAliveFetch } from '../http/keepalive-fetch.js';
 /** Categories whose payloads contain attacker-influenceable free text. */
 const UNTRUSTED_TEXT_CATEGORIES = new Set(['news', 'social', 'calendar']);
 const MAX_TEXT_LEN = 2000;
@@ -88,7 +89,7 @@ export async function getMarketIntelTool(args, deps) {
         url.searchParams.set('symbols', symbols.join(','));
     }
     try {
-        const res = await fetch(url.toString(), {
+        const res = await keepAliveFetch(url.toString(), {
             headers: { Authorization: `Bearer ${connectionToken}` },
             signal: AbortSignal.timeout(10_000),
         });

package/tools/get-relevant-learnings.js

@@ -15,6 +15,13 @@
 import { logger, formatError } from '../logger.js';
 const TAG = 'get-relevant-learnings';
 const VALID_APPLIES_AT = new Set(['entry', 'heartbeat', 'close']);
+// Curated learnings change on operator-curation timescales, but the agent is
+// instructed to read them at several points per heartbeat — and a looping
+// model can spam identical calls (observed live 2026-08-04: ~230 identical
+// calls in one beat drove a 272k-token context overflow). A short TTL keyed
+// on the exact query bounds both.
+const CACHE_TTL_MS = 30_000;
+const cache = new Map();
 export async function getRelevantLearningsTool(args, deps) {
     if (!deps.decisionsClient || !deps.userId) {
         // Ingest not wired — return empty, callable. Same shape as
@@ -32,6 +39,11 @@ export async function getRelevantLearningsTool(args, deps) {
             error: "applies_at is required and must be one of: 'entry', 'heartbeat', 'close'.",
         };
     }
+    const cacheKey = `${deps.userId}:${args.applies_at}:${args.setup_type ?? ''}:${args.regime ?? ''}:${args.verdict ?? ''}`;
+    const hit = cache.get(cacheKey);
+    if (hit && Date.now() - hit.at < CACHE_TTL_MS) {
+        return structuredClone(hit.result);
+    }
     let response;
     try {
         response = await deps.decisionsClient.getRelevantLearnings(deps.userId, {
@@ -56,10 +68,17 @@ export async function getRelevantLearningsTool(args, deps) {
             note: 'Webapp /api/internal/learnings returned no result; proceeding without curated learnings.',
         };
     }
-    return {
+    const result = {
         ok: true,
         learnings: response.learnings,
         total_candidates: response.totalCandidates,
         returned_count: response.returnedCount,
     };
+    cache.set(cacheKey, { at: Date.now(), result });
+    if (cache.size > 64) {
+        const oldest = cache.keys().next().value;
+        if (oldest !== undefined)
+            cache.delete(oldest);
+    }
+    return structuredClone(result);
 }

package/tools/get-resting-liquidity.js

@@ -7,5 +7,10 @@
 // `microstructure.bandedLiquidity` flag is off (= columns are NULL).
 import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getRestingLiquidityTool(args, deps) {
-    return fetchIntelApi(`/api/resting-liquidity/${enc(resolveIntelSymbol(deps, args.symbol))}`, deps);
+    // Cached: the microstructure assembler hits the same endpoint on the review
+    // path each heartbeat; advisory read, so a short TTL + tight timeout.
+    return fetchIntelApi(`/api/resting-liquidity/${enc(resolveIntelSymbol(deps, args.symbol))}`, deps, {
+        cacheTtlMs: 15_000,
+        timeoutMs: 10_000,
+    });
 }

package/tools/get-wave9-status.js

@@ -695,6 +695,23 @@ export async function getWave9StatusTool(deps) {
             const reversalDue = position
                 ? (position.side === 'long' ? daily.exitLong : daily.exitShort)
                 : false;
+            // Quiet-row compaction: no candidate and no held position — the evidence
+            // numerics (returns / ATR / reference close) are ~740B per symbol the
+            // agent never acts on; × 8 symbols × every heartbeat this was ~68% of
+            // the whole status payload. Rows with entries or a position keep the
+            // full shape unchanged. Deliberately NOT gated on daily.exitLong/
+            // exitShort: those flags are set for most symbols on any
+            // negative-momentum day, and with no held position there is nothing to
+            // exit — the first shipped version kept them and saved nothing
+            // (verified live 2026-08-04: 72 currentReturn mentions per beat).
+            if (entries.length === 0 && !position) {
+                return {
+                    symbol,
+                    capDecision: { status: 'not_candidate', reason: 'no_completed_daily_zero_cross' },
+                    entries: [],
+                    reversal: { due: false, timing: 'not_due' },
+                };
+            }
             return {
                 symbol,
                 currentReturn: daily.currentReturn,

package/tools/intel-api.d.ts

@@ -26,7 +26,16 @@ export interface FetchOptions {
     method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
     body?: unknown;
     timeoutMs?: number;
+    /** Opt-in TTL cache for GET reads. The same intel endpoints get hit several
+     *  times per heartbeat by different callers (agent tool + microstructure
+     *  assembler + repeated agent calls) — a short shared TTL collapses those
+     *  into one round-trip. Never set on polling reads that must observe fresh
+     *  server state (e.g. backtest status). */
+    cacheTtlMs?: number;
 }
+/** Test support: drop every cached GET response (the cache is module-level,
+ *  so suites that stub fetch with per-test responses must clear it). */
+export declare function clearIntelGetCache(): void;
 /** Encode a value for safe use in a URL path segment */
 export declare const enc: typeof encodeURIComponent;
 export declare function fetchIntelApi(path: string, deps: IntelApiDeps, options?: FetchOptions): Promise<Record<string, unknown> | {

package/tools/intel-api.js

@@ -1,5 +1,6 @@
 // Shared helper for Intelligence API calls.
 // All intelligence tools use Bearer token auth against intel.reefclaw.com.
+import { keepAliveFetch } from '../http/keepalive-fetch.js';
 import { HL_INTEL_PREFIX, fromIntelSymbol, toIntelSymbol } from '../venues/symbols.js';
 // ─── Venue-aware intel-symbol mapping (plan §5.3: the agent keeps using
 //     canonical symbols like BTC/USDC; these helpers translate at the intel
@@ -67,6 +68,13 @@ export function intelSymbolOnVenue(deps, intelSymbol) {
     const isHl = intelSymbol.startsWith(HL_INTEL_PREFIX);
     return (deps.venue ?? 'binance') === 'hyperliquid' ? isHl : !isHl;
 }
+const getCache = new Map();
+const GET_CACHE_MAX_ENTRIES = 256;
+/** Test support: drop every cached GET response (the cache is module-level,
+ *  so suites that stub fetch with per-test responses must clear it). */
+export function clearIntelGetCache() {
+    getCache.clear();
+}
 /** Encode a value for safe use in a URL path segment */
 export const enc = encodeURIComponent;
 export async function fetchIntelApi(path, deps, options) {
@@ -78,6 +86,29 @@ export async function fetchIntelApi(path, deps, options) {
         return { error: 'No intelligence URL configured. Set intelligenceUrl in openclaw.json plugin config.' };
     }
     const url = `${intelligenceUrl}${path}`;
+    const ttl = options?.cacheTtlMs ?? 0;
+    if (ttl > 0 && (options?.method ?? 'GET') === 'GET') {
+        const key = `${connectionToken}:${url}`;
+        const hit = getCache.get(key);
+        if (hit && Date.now() - hit.at < ttl) {
+            // structuredClone: callers must never alias each other's response object.
+            return hit.value.then((v) => structuredClone(v));
+        }
+        const value = fetchIntelApiUncached(url, connectionToken, options);
+        getCache.set(key, { at: Date.now(), value });
+        // Failures don't stick for the TTL — next caller retries fresh.
+        void value.then((v) => { if (v && typeof v === 'object' && 'error' in v)
+            getCache.delete(key); }, () => getCache.delete(key));
+        if (getCache.size > GET_CACHE_MAX_ENTRIES) {
+            const oldest = getCache.keys().next().value;
+            if (oldest !== undefined)
+                getCache.delete(oldest);
+        }
+        return value.then((v) => structuredClone(v));
+    }
+    return fetchIntelApiUncached(url, connectionToken, options);
+}
+async function fetchIntelApiUncached(url, connectionToken, options) {
     const headers = { Authorization: `Bearer ${connectionToken}` };
     const fetchInit = {
         method: options?.method ?? 'GET',
@@ -89,7 +120,7 @@ export async function fetchIntelApi(path, deps, options) {
         fetchInit.body = JSON.stringify(options.body);
     }
     try {
-        const res = await fetch(url, fetchInit);
+        const res = await keepAliveFetch(url, fetchInit);
         if (res.status === 401) {
             return { error: 'Invalid or expired ReefClaw connection token.' };
         }

package/tools/record-position-reviews.js

@@ -94,7 +94,6 @@ export async function recordPositionReviewsTool(args, deps) {
     // not load-bearing (each row carries its own reviewAt).
     let filed = 0;
     if (deps.decisionsClient && deps.userId) {
-        const promises = [];
         for (const r of reviews) {
             const stateEntry = deps.stateStore?.get(r.symbol);
             const positionId = stateEntry?.webappPositionId;
@@ -137,7 +136,8 @@ export async function recordPositionReviewsTool(args, deps) {
                 deps.stateStore.recordReview(r.symbol, r.verdict, undefined, r.thesis_status);
             }
         }
-        await Promise.allSettled(promises);
+        // POSTs above are fire-and-forget by design — durability is the client's
+        // in-flight set + drain(), not an await here.
     }
     else {
         logger.info(TAG, `record_position_reviews validated ${reviews.length} reviews; no decisionsClient configured (off-mode).`);

package/tools/scan-pairs.js

@@ -129,8 +129,20 @@ function learningMatches(learning, setupType, regime) {
 }
 export async function scanPairsTool(args, deps, decisionsDeps) {
     const minScore = args.min_score ?? 4;
-    // 1. Fetch all symbol facts (cached, shared with get_setup_detail)
-    const factsRes = await getAllFactsCached(deps);
+    // Facts, strategies, and entry learnings are three independent reads (two
+    // intel, one webapp) — start them all now and await in the original order,
+    // so error precedence (facts → strategies → learnings-fail-quiet) and every
+    // early-return body stay byte-identical while the round-trips overlap.
+    const factsPromise = getAllFactsCached(deps);
+    const stratPromise = getStrategiesCached(deps);
+    const learningsPromise = decisionsDeps?.decisionsClient && decisionsDeps.userId
+        ? getEntryLearningsCached(decisionsDeps.decisionsClient, decisionsDeps.userId)
+        : Promise.resolve([]);
+    // An early return below must not leave a floating rejection behind.
+    stratPromise.catch(() => { });
+    learningsPromise.catch(() => { });
+    // 1. All symbol facts (cached, shared with get_setup_detail)
+    const factsRes = await factsPromise;
     if ('error' in factsRes)
         return factsRes;
     // Venue scope: only rank symbols this box can actually trade. Without this
@@ -154,8 +166,8 @@ export async function scanPairsTool(args, deps, decisionsDeps) {
                 : 'No symbol facts available. Intelligence service may still be computing initial data.',
         };
     }
-    // 2. Fetch user's active strategies (cached, shared with get_setup_detail)
-    const stratRes = await getStrategiesCached(deps);
+    // 2. User's active strategies (cached, shared with get_setup_detail)
+    const stratRes = await stratPromise;
     if ('error' in stratRes)
         return stratRes;
     const strategies = stratRes;
@@ -171,13 +183,10 @@ export async function scanPairsTool(args, deps, decisionsDeps) {
     }
     // 3. Evaluate all strategies against all facts
     const results = scanAllPairs(strategies, facts, minScore);
-    // 4. Fetch user's confirmed entry-time learnings (optional path — fail
-    //    quietly when the decisions client isn't wired, e.g. in dev or in
-    //    tests that exercise the pre-learning behaviour).
-    let entryLearnings = [];
-    if (decisionsDeps?.decisionsClient && decisionsDeps.userId) {
-        entryLearnings = await getEntryLearningsCached(decisionsDeps.decisionsClient, decisionsDeps.userId);
-    }
+    // 4. User's confirmed entry-time learnings (optional path — resolves []
+    //    when the decisions client isn't wired, e.g. in dev or in tests that
+    //    exercise the pre-learning behaviour).
+    const entryLearnings = await learningsPromise;
     const rankings = [];
     const vetoed = [];
     for (const r of results) {

package/types.d.ts

@@ -63,6 +63,13 @@ export interface CcxtPosition {
     contractSize: number;
     entryPrice: number;
     markPrice: number;
+    /** Paper only: true when NO quote was available for this symbol, so
+     *  `markPrice` is a fabricated fallback (entryPrice) rather than a real mark.
+     *  Consumers that make protective decisions MUST NOT read `markPrice` as
+     *  truth when this is set — a fabricated "flat since entry" mark reads as a
+     *  healthy position and is how a breached stop stayed invisible for 35h.
+     *  Undefined on live (real marks come from the exchange). */
+    markPriceStale?: boolean;
     notional: number;
     unrealizedPnl: number;
     percentage: number;