@reefclaw/openclaw-plugin 0.1.23 → 0.1.25

package/tools/get-funding-context.js

@@ -12,5 +12,10 @@
 // FUNDING_OVERLAY flag is off or the symbol has < 100 30d samples.
 import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getFundingContextTool(args, deps) {
-    return fetchIntelApi(`/api/funding/${enc(resolveIntelSymbol(deps, args.symbol))}`, deps);
+    // Server-side percentile context already has a 15-min TTL — 60s here just
+    // collapses same-heartbeat repeats.
+    return fetchIntelApi(`/api/funding/${enc(resolveIntelSymbol(deps, args.symbol))}`, deps, {
+        cacheTtlMs: 60_000,
+        timeoutMs: 10_000,
+    });
 }

package/tools/get-liquidation-levels.js

@@ -3,5 +3,9 @@
 import { fetchIntelApi, enc, resolveIntelSymbol } from './intel-api.js';
 export async function getLiquidationLevelsTool(args, deps) {
     const hours = args.hours ?? 24;
-    return fetchIntelApi(`/api/liquidation-levels/${enc(resolveIntelSymbol(deps, args.symbol))}?hours=${hours}`, deps);
+    // Historical clusters move slowly — 30s TTL collapses per-position repeats.
+    return fetchIntelApi(`/api/liquidation-levels/${enc(resolveIntelSymbol(deps, args.symbol))}?hours=${hours}`, deps, {
+        cacheTtlMs: 30_000,
+        timeoutMs: 10_000,
+    });
 }

package/tools/get-liquidation-pulse.js

@@ -13,7 +13,13 @@ export async function getLiquidationPulseTool(args, deps) {
         params.set('symbol', resolveIntelSymbol(deps, args.symbol));
     const windowSeconds = clamp(args.window_seconds ?? 60, 5, 300);
     params.set('window_seconds', String(windowSeconds));
-    return fetchIntelApi(`/api/liquidation-pulse?${params.toString()}`, deps);
+    // 10s TTL: short enough that an active_cascade classification is never
+    // stale-read into the override decision (cascades persist 60-180s), long
+    // enough to collapse the per-position repeats within one heartbeat.
+    return fetchIntelApi(`/api/liquidation-pulse?${params.toString()}`, deps, {
+        cacheTtlMs: 10_000,
+        timeoutMs: 10_000,
+    });
 }
 function clamp(n, lo, hi) {
     if (!Number.isFinite(n))

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/hl-provision-agent-wallet.js

@@ -96,22 +96,40 @@ export async function hlProvisionAgentWalletTool(args, deps) {
         const derived = await deriveAddressFromPrivateKey(existingKey);
         if (derived.ok) {
             const masterMatches = existingMaster != null && existingMaster.toLowerCase() === walletAddress.toLowerCase();
-            // ★ Honour a CHANGED network on the resume path. The same keypair is
-            // valid on both Hyperliquid networks, so switching mainnet<->testnet
-            // must not require regenerating the wallet — but the stored flag has to
-            // follow, or the box boots against the network the operator did NOT
-            // pick. Before this, unticking "Use Hyperliquid testnet" after
-            // provisioning silently kept testnet:true, and the approval was signed
-            // for Testnet while the operator believed they were on mainnet
-            // (observed live 2026-08-03).
-            if (masterMatches && existingTestnet !== testnet) {
+            // ★ Re-ACTIVATE the venue on resume (E2E audit 2026-08-11 #6) and honour
+            // a CHANGED network in the same write.
+            //
+            // Venue: the resume path used to write NOTHING unless the network flag
+            // moved — so a box whose active venue was still binance (HL provisioned
+            // earlier and switched back, or a live-Binance box that just clicked
+            // through the confirm-switch dialog above) kept `venue:'binance'` on
+            // disk. hl_agent_wallet_status only reports configured when
+            // `exchange.venue==='hyperliquid'`, so the guided flow dead-ended
+            // polling configured:false forever, and the confirm dialog "switched"
+            // nothing. By this point the venue-switch confirm gate has already run,
+            // so the activation write is authorized. buildVenueExchangeConfig with
+            // empty fields activates the venue while keeping BOTH venues'
+            // credentials (the merge contract).
+            //
+            // Network: the same keypair is valid on both Hyperliquid networks, so
+            // mainnet<->testnet must not require regenerating — but the stored flag
+            // has to follow, or the box boots against the network the operator did
+            // NOT pick (observed live 2026-08-03: approval signed for Testnet while
+            // the operator believed mainnet).
+            const needsVenueActivation = fromVenue !== 'hyperliquid';
+            if (masterMatches && (needsVenueActivation || existingTestnet !== testnet)) {
                 try {
                     updatePluginConfig({ exchange: buildVenueExchangeConfig(existingExchange, 'hyperliquid', {}, testnet) }, deps.configPath);
+                    if (needsVenueActivation) {
+                        logger.info(TAG, 'venue re-activated: hyperliquid (existing agent wallet resumed)');
+                    }
+                    if (existingTestnet !== testnet) {
+                        logger.info(TAG, `network switched to ${testnet ? 'TESTNET' : 'MAINNET'} (same agent wallet)`);
+                    }
                     existingTestnet = testnet;
-                    logger.info(TAG, `network switched to ${testnet ? 'TESTNET' : 'MAINNET'} (same agent wallet)`);
                 }
                 catch (err) {
-                    logger.warn(TAG, `could not persist network change: ${err instanceof Error ? err.message : String(err)}`);
+                    logger.warn(TAG, `could not persist venue/network change: ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
             return {

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/reentry-cooldown.d.ts

@@ -0,0 +1,33 @@
+import type { ReentryExitRecord, ReentryTracker } from '../portfolio/reentry-tracker.js';
+export type ReentryCooldownMode = 'off' | 'shadow' | 'observe' | 'enforce';
+export interface ReentryCooldownEval {
+    /** Mode the gate ran under (never 'off' — off is not evaluated). */
+    mode: Exclude<ReentryCooldownMode, 'off'>;
+    /** A lossy same-symbol close exists within the cooldown window. */
+    triggered: boolean;
+    /** triggered && mode === 'enforce' — caller must reject the order. */
+    blocked: boolean;
+    code: 'no_recent_loss' | 'cooldown_active' | 'scale_in_exempt' | 'operator_approved_exempt' | 'tracker_unavailable';
+    cooldownMinutes: number;
+    /** Minutes since the arming loss (only when triggered). */
+    minutesSinceLoss?: number;
+    /** The arming loss (only when triggered). */
+    lastLoss?: Pick<ReentryExitRecord, 'side' | 'setupType' | 'closedAtMs' | 'lossSource'>;
+}
+export interface ReentryCooldownInputs {
+    symbol: string;
+    mode: Exclude<ReentryCooldownMode, 'off'>;
+    tracker: Pick<ReentryTracker, 'lastLossyExit'> | undefined;
+    /** Current trading book — filters tracker records after a paper↔live flip. */
+    book: 'paper' | 'live';
+    cooldownMinutes: number;
+    /** Same-symbol position already open → this order is a scale-in, exempt. */
+    hasOpenPosition: boolean;
+    /** ProposalDecisionListener fire of an operator-APPROVED proposal, exempt. */
+    isListenerFire: boolean;
+    nowMs?: number;
+}
+export declare function evaluateReentryCooldown(inputs: ReentryCooldownInputs): ReentryCooldownEval;
+/** Agent-facing rejection for enforce mode. Names the gate, the remaining
+ *  wait, and the honest path forward — no bypass hint by design. */
+export declare function buildReentryCooldownRejection(ev: ReentryCooldownEval, symbol: string): string;

package/tools/reentry-cooldown.js

@@ -0,0 +1,74 @@
+// Re-entry cooldown gate — blocks (mode-laddered) a NEW entry on a symbol
+// whose last close within the cooldown window was a LOSS.
+//
+// Evidence (2026-09-02, full live journal): entries opened within 60 minutes
+// of a same-symbol losing close ran mean −0.077R (n=58) vs +0.090R for all
+// other entries (n=1151) at identical ~41% win rates, plus the extra fee load
+// — the LINK/DOGE churn signature of the 2026-06 investigation recurring on
+// the HL live book. Suggestive, not proven, at n=58 — which is exactly what
+// the shadow rung is for: this ships `off` by default, is flipped shadow-first
+// via the central gate channel (`agent_config.gates.reentryCooldown`), and
+// tags would-block entries into position_entries.metadata.reentry_cooldown so
+// the forward counterfactual is measurable in the journal before any enforce
+// decision.
+//
+// Scope guards (all fail OPEN — this gate can only ever suppress a NEW entry,
+// never an exit, close, stop, or emergency action):
+//   - generic entries only (wave9 has its own frozen admission policy);
+//   - scale-ins exempt (position already open — entry already happened);
+//   - operator-approved proposal fires exempt (human already said yes);
+//   - tracker unavailable → pass.
+//
+// Mode semantics mirror the exit gate (docs/CLAUDE/exit-gate.md):
+//   off     — not evaluated; byte-identical to the pre-gate path.
+//   shadow  — evaluated + logged + journal-tagged; never affects the order.
+//   observe — as shadow, but a triggered eval logs at WARN (operator-visible).
+//   enforce — a triggered eval hard-rejects create_order with a recovery hint.
+export function evaluateReentryCooldown(inputs) {
+    const base = {
+        mode: inputs.mode,
+        triggered: false,
+        blocked: false,
+        cooldownMinutes: inputs.cooldownMinutes,
+    };
+    if (inputs.isListenerFire)
+        return { ...base, code: 'operator_approved_exempt' };
+    if (inputs.hasOpenPosition)
+        return { ...base, code: 'scale_in_exempt' };
+    if (!inputs.tracker)
+        return { ...base, code: 'tracker_unavailable' };
+    const nowMs = inputs.nowMs ?? Date.now();
+    const windowMs = inputs.cooldownMinutes * 60_000;
+    const loss = inputs.tracker.lastLossyExit(inputs.symbol, windowMs, {
+        mode: inputs.book,
+        nowMs,
+    });
+    if (!loss)
+        return { ...base, code: 'no_recent_loss' };
+    const minutesSinceLoss = Math.max(0, Math.round((nowMs - loss.closedAtMs) / 60_000));
+    return {
+        ...base,
+        triggered: true,
+        blocked: inputs.mode === 'enforce',
+        code: 'cooldown_active',
+        minutesSinceLoss,
+        lastLoss: {
+            side: loss.side,
+            setupType: loss.setupType,
+            closedAtMs: loss.closedAtMs,
+            lossSource: loss.lossSource,
+        },
+    };
+}
+/** Agent-facing rejection for enforce mode. Names the gate, the remaining
+ *  wait, and the honest path forward — no bypass hint by design. */
+export function buildReentryCooldownRejection(ev, symbol) {
+    const remaining = Math.max(1, ev.cooldownMinutes - (ev.minutesSinceLoss ?? 0));
+    return (`create_order rejected (reentry cooldown): ${symbol} closed at a LOSS ` +
+        `${ev.minutesSinceLoss}m ago and the operator-configured cooldown is ` +
+        `${ev.cooldownMinutes}m — ~${remaining}m remaining. This is a mechanical ` +
+        `gate against re-entry churn (measured −0.17R/trade edge gap on re-entries ` +
+        `within the window). Do not retry this symbol until the cooldown lapses; ` +
+        `spend the time re-scoring the setup — if it is still valid then, enter then. ` +
+        `Other symbols are unaffected.`);
+}

package/tools/scan-pairs.d.ts

@@ -13,6 +13,13 @@ export interface ScanPairsDecisionsDeps {
     /** Re-entry tracker (issue #204) — flags setups already traded within the
      *  current signal bar. Indication only; nothing is filtered out. */
     reentryTracker?: ReentryTracker;
+    /** WS2 directional scoreboard inputs (docs/MARKET_ADAPTIVITY_PLAN.md §3) —
+     *  tracked open positions (state store; no exchange round-trip) + the
+     *  current book. Indication only, like everything else in this block. */
+    openPositions?: () => Array<{
+        side: 'long' | 'short';
+    }>;
+    book?: () => 'paper' | 'live';
 }
 export declare function scanPairsTool(args: ScanPairsArgs, deps: IntelApiDeps, decisionsDeps?: ScanPairsDecisionsDeps): Promise<Record<string, unknown> | {
     error: string;

package/tools/scan-pairs.js

@@ -17,8 +17,31 @@
 // heartbeat the agent was rejecting post-scorecard pre-fix.
 import { intelSymbolOnVenue, presentIntelSymbol, resolveIntelSymbol } from './intel-api.js';
 import { scanAllPairs } from '../strategy/evaluator.js';
+import { buildDirectionalScoreboard } from '../portfolio/directional-scoreboard.js';
 import { getAllFactsCached, getStrategiesCached, __testing__ as cacheTesting } from './intel-cache.js';
 import { normalizeSetupFamily, resolveTriggerFamilies } from '../learning/setup-family.js';
+/** WS2 kill-switch — RC_CHANGE_OF_CHARACTER=off suppresses the market-shift
+ *  cautions + directional scoreboard without a redeploy. Default on. */
+function changeOfCharacterEnabled() {
+    return (process.env.RC_CHANGE_OF_CHARACTER ?? '').toLowerCase() !== 'off';
+}
+/** Tape line for the scoreboard from the market leader's fact (BTC on this
+ *  venue; falls back to the first fact so alt-only books still get a tape). */
+function leaderTapeLine(deps, facts) {
+    const leader = facts.find((f) => presentIntelSymbol(deps, f.symbol).toUpperCase().startsWith('BTC/')) ??
+        facts[0];
+    const coc = leader?.changeOfCharacter;
+    if (!coc)
+        return {};
+    const sym = presentIntelSymbol(deps, leader.symbol).split('/')[0];
+    const sign = (v) => (v >= 0 ? '+' : '');
+    return {
+        line: `${sym} 4h ${sign(coc.return4hPct)}${coc.return4hPct}% ` +
+            `(${sign(coc.tape4hAtr)}${coc.tape4hAtr}×ATR)` +
+            (coc.flags.length > 0 ? ` [${coc.flags.join(', ')}]` : ''),
+        caution: coc.flags.length > 0 ? coc.summary : undefined,
+    };
+}
 const LEARNINGS_TTL_MS = 60_000;
 const entryLearningsCache = new Map();
 /** Family-keying gate (2026-06-22). Off by default → byte-identical exact-match
@@ -129,8 +152,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 +189,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,19 +206,20 @@ 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 = [];
+    // WS2 change-of-character: per-symbol lookup + market-leader tape line.
+    const cocOn = changeOfCharacterEnabled();
+    const factBySymbol = new Map(facts.map(f => [f.symbol, f]));
     for (const r of results) {
         const matches = entryLearnings.filter(l => learningMatches(l, r.strategy, r.regime));
         const agentSymbol = presentIntelSymbol(deps, r.symbol);
         const reentryCaution = decisionsDeps?.reentryTracker?.cautionFor(agentSymbol, r.strategy);
+        const coc = cocOn ? factBySymbol.get(r.symbol)?.changeOfCharacter : undefined;
         const out = {
             // Agent-facing form: on hyperliquid the agent must see the symbol it
             // can hand straight to create_order ('BTC/USDC'), never 'HL_BTC'.
@@ -194,6 +230,7 @@ export async function scanPairsTool(args, deps, decisionsDeps) {
             conditions: `${r.conditionsMet}/${r.conditionsTotal} met: ${r.conditions.filter(c => c.met).map(c => c.name).join(', ')}`,
             summary: r.summary,
             ...(reentryCaution ? { reentry_caution: reentryCaution } : {}),
+            ...(coc && coc.flags.length > 0 && coc.summary ? { market_shift_caution: coc.summary } : {}),
         };
         if (matches.length === 0) {
             rankings.push(out);
@@ -214,10 +251,29 @@ export async function scanPairsTool(args, deps, decisionsDeps) {
     const noSetup = facts
         .filter(f => !setupSymbols.has(f.symbol))
         .map(f => presentIntelSymbol(deps, f.symbol));
+    // WS2 top-level indication: leader tape + shift caution + the directional
+    // scoreboard (book tilt vs recent per-direction outcomes vs tape). All
+    // indication-only; RC_CHANGE_OF_CHARACTER=off suppresses without redeploy.
+    let marketCaution;
+    let scoreboard;
+    if (cocOn) {
+        const tape = leaderTapeLine(deps, facts);
+        marketCaution = tape.caution;
+        if (decisionsDeps?.reentryTracker) {
+            scoreboard = buildDirectionalScoreboard({
+                openPositions: decisionsDeps.openPositions?.() ?? [],
+                exitRecords: decisionsDeps.reentryTracker.getRecords(),
+                book: decisionsDeps.book?.() ?? 'paper',
+                tapeLine: tape.line,
+            });
+        }
+    }
     return {
         timestamp: new Date().toISOString(),
         pairs_scanned: facts.length,
         setups_found: results.length,
+        ...(marketCaution ? { market_caution: marketCaution } : {}),
+        ...(scoreboard ? { directional_scoreboard: scoreboard } : {}),
         rankings,
         vetoed_setups: vetoed.length > 0 ? vetoed : undefined,
         no_setup: noSetup.length > 5

package/tools/set-exchange-credentials.js

@@ -34,12 +34,31 @@ import { parseVenue } from '../venues/registry.js';
 import { unsealCredentials, SealedEnvelopeError } from '../security/sealed-credentials.js';
 import { logger } from '../logger.js';
 const TAG = 'set-exchange-credentials';
+/** Non-secret CONTROL flags honored from the PLAINTEXT SIBLINGS of a sealed
+ *  envelope (E2E audit 2026-08-11 #5). The envelope's anti-smuggle property —
+ *  "plaintext siblings are ignored" — exists so a mixed payload can't override
+ *  sealed CREDENTIAL values. But the dashboard sends `confirm_venue_switch`
+ *  as a sibling NEXT TO `sealed` (it is not a secret and the sealer encrypts
+ *  only the per-venue credential payload), so dropping every sibling made the
+ *  confirm retry look unconfirmed forever: any live venue-switcher on a box
+ *  with a transport key hit an infinite confirm loop. The flags below are
+ *  safe to honor from plaintext because they cannot change WHAT gets stored
+ *  (the sealed payload alone decides that) — they only acknowledge a warn
+ *  step for the request the operator themselves sealed. A value INSIDE the
+ *  envelope still wins (sealed-beats-plaintext is preserved). */
+const SEALED_SIBLING_CONTROL_FLAGS = ['confirm_venue_switch'];
 /** Open a sealed envelope into plain args, or return a renderable error. */
 export function resolveSealedArgs(args, configDir) {
     if (args?.sealed == null)
         return { args, sealed: false };
     try {
         const plain = unsealCredentials(args.sealed, configDir);
+        for (const flag of SEALED_SIBLING_CONTROL_FLAGS) {
+            const sibling = args[flag];
+            if (plain[flag] === undefined && sibling !== undefined) {
+                plain[flag] = sibling;
+            }
+        }
         return { args: plain, sealed: true };
     }
     catch (err) {

package/tools/set-trading-mode.d.ts

@@ -1,6 +1,8 @@
 import type { PluginRuntime } from '../onboarding/runtime.js';
 import type { IExchangeAdapter } from '../exchange-adapter.js';
 import type { TradingMode } from '../types.js';
+import type { HlCredentials } from '../venues/hyperliquid/hl-private.js';
+import { type HlAgentApprovalVerdict } from '../venues/hyperliquid/hl-agent-wallet.js';
 import { type VenueId } from '../venues/registry.js';
 export interface SetTradingModeArgs {
     mode: TradingMode;
@@ -27,6 +29,10 @@ export interface SetTradingModeDeps {
      *  wired to the boot venue and a mixed-venue runtime is not a valid state.
      *  Absent (legacy tests) → guard skipped. */
     bootVenue?: VenueId;
+    /** Injectable approval check (tests). DEFAULTS TO THE REAL ONE — unlike
+     *  bootVenue this gate is on unless explicitly stubbed, so production
+     *  wiring can never forget it. */
+    hlApprovalCheck?: (creds: HlCredentials) => Promise<HlAgentApprovalVerdict>;
     /** Override the config file path — tests use this. */
     configPath?: string;
 }