@reefclaw/openclaw-plugin 0.1.24 → 0.1.26

package/signals/change-of-character.js

@@ -0,0 +1,93 @@
+// ⚠️ GENERATED FILE — DO NOT EDIT.
+// Canonical source of truth: shared/src/signals/change-of-character.ts
+// Regenerate: node scripts/sync-shared-code.mjs  (enforced by shared-code-sync.test.ts)
+//
+// This copy exists because this package builds with tsc and deploys as a
+// self-contained tree that strips workspace deps, so it cannot import
+// @reefclaw/shared runtime code across the deploy boundary.
+// Change-of-character detection — WS2 of docs/MARKET_ADAPTIVITY_PLAN.md.
+//
+// The 2026-09 adaptivity investigation found the agent keeps trading a stale
+// directional view after event-driven regime flips because (a) the regime
+// label is computed from realized bars and lags a shock by hours, and (b) no
+// input ever shows it the contradiction. This module computes the two fast
+// counter-evidence facts from data the fact-computer already has in hand —
+// NO new DB queries (the intel hot-query chunk-exclusion rule is not in play):
+//
+//   - SHOCK: the last ~30 minutes moved a multiple of the hourly ATR. An
+//     hourly ATR is roughly "a typical hour's range", so 2×ATR inside 30m is
+//     ~4× the typical rate — announcement territory.
+//   - REGIME/TAPE DISAGREEMENT: the regime label says TREND_UP (or DOWN) but
+//     the realized 4h tape moved ≥2×ATR the other way — the label is lagging.
+//
+// Pure function, deterministic, fail-open: insufficient bars or a degenerate
+// ATR returns undefined and every consumer treats that as "no signal".
+// Thresholds are exported so the soak can be re-cut without archaeology.
+// Canonical copy lives in shared/src/signals/ and is synced to
+// intelligence/ + plugin/ via scripts/sync-shared-code.mjs (drift-tested).
+/** 30m move ≥ this ×ATR(1h) ⇒ 'shock'. */
+export const SHOCK_ATR_MULT_30M = 2.0;
+/** 4h tape opposing a directional regime label by ≥ this ×ATR(1h) ⇒ 'regime_tape_disagreement'. */
+export const DISAGREEMENT_ATR_MULT_4H = 2.0;
+const fin = (v) => Number.isFinite(v);
+const round2 = (v) => Math.round(v * 100) / 100;
+export function computeChangeOfCharacter(inputs) {
+    const { ohlcv5m, ohlcv1h, atr14, currentPrice, regime } = inputs;
+    if (!fin(atr14) || atr14 <= 0 || !fin(currentPrice) || currentPrice <= 0)
+        return undefined;
+    if (!Array.isArray(ohlcv5m) || ohlcv5m.length < 7)
+        return undefined;
+    if (!Array.isArray(ohlcv1h) || ohlcv1h.length < 5)
+        return undefined;
+    // ~30m window = last 6 closed 5m bars; the reference close sits just before it.
+    const last6 = ohlcv5m.slice(-6);
+    const ref30m = ohlcv5m[ohlcv5m.length - 7].close;
+    const ref1h = ohlcv1h[ohlcv1h.length - 2].close;
+    const ref4h = ohlcv1h[ohlcv1h.length - 5].close;
+    if (!fin(ref30m) || ref30m <= 0 || !fin(ref1h) || ref1h <= 0 || !fin(ref4h) || ref4h <= 0) {
+        return undefined;
+    }
+    const shock30mAtr = Math.abs(currentPrice - ref30m) / atr14;
+    const hi30 = Math.max(...last6.map((b) => b.high));
+    const lo30 = Math.min(...last6.map((b) => b.low));
+    const range30mAtr = fin(hi30) && fin(lo30) && hi30 >= lo30 ? (hi30 - lo30) / atr14 : 0;
+    const return1hPct = (currentPrice / ref1h - 1) * 100;
+    const return4hPct = (currentPrice / ref4h - 1) * 100;
+    const tape4hAtr = (currentPrice - ref4h) / atr14;
+    const atrPct = (atr14 / currentPrice) * 100;
+    const flags = [];
+    if (Math.max(shock30mAtr, range30mAtr) >= SHOCK_ATR_MULT_30M)
+        flags.push('shock');
+    const labelDir = regime === 'TREND_UP' ? 1 : regime === 'TREND_DOWN' ? -1 : 0;
+    const opposing = labelDir !== 0 && Math.sign(tape4hAtr) === -labelDir;
+    if (opposing && Math.abs(tape4hAtr) >= DISAGREEMENT_ATR_MULT_4H) {
+        flags.push('regime_tape_disagreement');
+    }
+    const out = {
+        shock30mAtr: round2(shock30mAtr),
+        range30mAtr: round2(range30mAtr),
+        return1hPct: round2(return1hPct),
+        return4hPct: round2(return4hPct),
+        tape4hAtr: round2(tape4hAtr),
+        atrPct: round2(atrPct),
+        flags,
+    };
+    if (flags.length > 0)
+        out.summary = buildSummary(out, regime);
+    return out;
+}
+function buildSummary(c, regime) {
+    const parts = [];
+    if (c.flags.includes('shock')) {
+        parts.push(`SHOCK: last 30m moved ${round2(Math.max(c.shock30mAtr, c.range30mAtr))}×ATR ` +
+            `(${c.return1hPct >= 0 ? '+' : ''}${c.return1hPct}% on the hour)`);
+    }
+    if (c.flags.includes('regime_tape_disagreement')) {
+        parts.push(`regime label '${regime}' contradicts the 4h tape ` +
+            `(${c.tape4hAtr >= 0 ? '+' : ''}${c.tape4hAtr}×ATR / ` +
+            `${c.return4hPct >= 0 ? '+' : ''}${c.return4hPct}%) — the label LAGS realized price`);
+    }
+    return (`MARKET SHIFT — ${parts.join('; ')}. Re-derive direction from fresh price data ` +
+        `before entering; on open positions, check the pinned invalidation FIRST and do not ` +
+        `lean on prior theses formed before this move.`);
+}

package/signals/types.js

@@ -1,6 +1,6 @@
 // Re-export shim for the plugin-side strategy evaluator (facts-out).
 //
-// The generated eval-core copies (registry, strategy-adapter, direction/entry/
+// The generated evaluator-core copies (registry, strategy-adapter, direction/entry/
 // stop-rules) import their types from `./types.js`. The canonical definitions
 // live in @reefclaw/shared (type-only → erased at runtime), so this shim makes
 // those relative imports resolve inside the plugin tree without pulling any

package/simulator/exchange-simulator.d.ts

@@ -76,7 +76,11 @@ export declare class ExchangeSimulator extends EventEmitter {
      *  market branch prices off THIS instead of the last tick, and skips the
      *  stale-quote guard — the caller supplied the price, so quote age is
      *  irrelevant, and a protective exit must never be blocked (issue #202). */
-    referencePrice?: number): CcxtOrder;
+    referencePrice?: number, 
+    /** Set ONLY by closePosition for mechanical/operator-initiated exits —
+     *  exempts them from the startup lockout. Never reachable from the
+     *  agent-facing create_order path. */
+    protectiveExit?: boolean): CcxtOrder;
     cancelOrder(orderId: string): CcxtOrder;
     cancelAllOrders(symbol?: string): CcxtOrder[];
     /**

package/simulator/exchange-simulator.js

@@ -290,17 +290,29 @@ export class ExchangeSimulator extends EventEmitter {
      *  market branch prices off THIS instead of the last tick, and skips the
      *  stale-quote guard — the caller supplied the price, so quote age is
      *  irrelevant, and a protective exit must never be blocked (issue #202). */
-    referencePrice) {
+    referencePrice, 
+    /** Set ONLY by closePosition for mechanical/operator-initiated exits —
+     *  exempts them from the startup lockout. Never reachable from the
+     *  agent-facing create_order path. */
+    protectiveExit) {
         // ---- Startup trade lockout ----
         // Block trades during the first 15s after gateway restart IF there were
         // existing positions at startup. This prevents stale agent sessions from
         // selling positions before the session is cleared and the agent re-reads SKILL.md.
         // Only activates when positions exist (nothing to protect if starting empty).
+        // Protective exits pass through: a stop breached 3s after a restart must
+        // close NOW — blocking the watcher here left positions unprotected for
+        // the whole window (open item since 2026-07-27).
         const elapsed = Date.now() - this.startupTime;
         if (this.hadPositionsAtStartup && elapsed < ExchangeSimulator.STARTUP_LOCKOUT_MS) {
-            const remaining = Math.ceil((ExchangeSimulator.STARTUP_LOCKOUT_MS - elapsed) / 1000);
-            logger.warn(TAG, `STARTUP LOCKOUT: Blocked ${side} ${amount} ${symbol} — ${remaining}s remaining. This prevents stale session trades during restart.`);
-            throw new Error(`Trade blocked: startup lockout (${remaining}s remaining). The gateway just restarted — wait for the agent to re-read its instructions and check positions before trading.`);
+            if (protectiveExit) {
+                logger.info(TAG, `Startup lockout bypassed for protective exit: ${side} ${amount} ${symbol}`);
+            }
+            else {
+                const remaining = Math.ceil((ExchangeSimulator.STARTUP_LOCKOUT_MS - elapsed) / 1000);
+                logger.warn(TAG, `STARTUP LOCKOUT: Blocked ${side} ${amount} ${symbol} — ${remaining}s remaining. This prevents stale session trades during restart.`);
+                throw new Error(`Trade blocked: startup lockout (${remaining}s remaining). The gateway just restarted — wait for the agent to re-read its instructions and check positions before trading.`);
+            }
         }
         if (amount <= 0) {
             throw new Error('Order amount must be positive');
@@ -410,9 +422,15 @@ export class ExchangeSimulator extends EventEmitter {
         if (closeReason) {
             position.metadata = { ...(position.metadata ?? {}), closeReason };
         }
-        // Create opposing market order to close the position
+        // Create opposing market order to close the position.
+        // Mechanical / operator-initiated exits (stop_watcher, exchange_target,
+        // emergency, operator, bracket_attach_failed, …) must never wait out the
+        // startup lockout — a stop breached seconds after a restart has to close
+        // immediately. Only discretionary closes ('agent' or reason-less) keep
+        // the stale-session guard.
+        const protectiveExit = closeReason !== undefined && closeReason !== 'agent';
         const closeSide = position.side === 'long' ? 'sell' : 'buy';
-        return this.createOrder(symbol, closeSide, 'market', position.quantity, undefined, undefined, referencePrice);
+        return this.createOrder(symbol, closeSide, 'market', position.quantity, undefined, undefined, referencePrice, protectiveExit);
     }
     /** Paper-only: move an open position's MUTABLE protective levels (stopPrice /
      *  targetPrice) in place and persist, WITHOUT the close+reopen round-trip

package/simulator/types.d.ts

@@ -150,6 +150,17 @@ export interface PositionMetadata {
     /** The agent's stated profit-realization plan, pinned at entry (indication,
      *  not an enforced mechanic). */
     realizationRule?: RealizationRule;
+    /** Re-entry cooldown gate evaluation, present ONLY when the gate TRIGGERED on this
+     *  entry (a same-symbol loss within the window) and the order fired anyway
+     *  (shadow/observe). Journaled to position_entries.metadata.reentry_cooldown
+     *  so the shadow soak can measure the would-block cohort's forward outcomes
+     *  against untagged entries (tools/reentry-cooldown.ts). */
+    reentryCooldown?: {
+        mode: 'shadow' | 'observe' | 'enforce';
+        minutesSinceLoss: number;
+        cooldownMinutes: number;
+        wouldBlock: boolean;
+    };
     /** Entry price as it was at the moment of the FIRST fill, frozen. MFE-in-R is
      *  denominated against this (and originalStopPrice), never against the
      *  position's running averaged entryPrice — otherwise a scale-in would

package/skills/reefclaw/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: reefclaw
-version: 0.0.9
+version: 0.0.10
 description: ReefClaw trading control room — bootstrap (connects your agent; the full trading instructions arrive after first connect as a signed, signature-verified update)
 author: ReefClaw
 homepage: https://reefclaw.com
@@ -108,7 +108,7 @@ That is the whole install. It places the plugin, sets up the connector, restarts
 
 **Do not attempt to perform this install yourself, and do not work around it if it is unavailable to you.** Specifically: do not edit OpenClaw's configuration to enable chat install commands, do not add anyone to an owner or elevated-exec allowlist, do not enable elevated mode, and do not restart the gateway to widen your own permissions. If you cannot run the command, the correct outcome is to hand the user the one line above and let them run it deliberately. A trading integration is exactly the kind of software whose installation a human should perform knowingly.
 
-**If the user installs via ClawHub instead** and sees a security warning ("Security scan: suspicious"): that is expected and honest — ReefClaw is a trading plugin, and it discloses live-trading capability, exchange-credential storage, and remote instruction updates, which ClawHub flags for review (its linked security page has the details; VirusTotal reports the artifact clean). The chat command cannot acknowledge that warning, so the user should either use the `npx` line above, or — having read the warning — run `openclaw plugins install clawhub:@reefclaw/openclaw-plugin --acknowledge-clawhub-risk` themselves in a terminal.
+**If the user installs via ClawHub instead** — no terminal needed on OpenClaw 2026.8.1 or newer: either OpenClaw's Control UI (Plugins → Discover → search "reefclaw" → Install → accept the listed capabilities), or the chat command `/plugins install clawhub:@reefclaw/openclaw-plugin` followed, after reading the capability list it replies with, by the same command plus `--accept-capabilities` (the chat command needs `commands.plugins: true` in openclaw.json, which only the user sets). ClawHub labels the plugin "Security scan: suspicious". That is expected and honest — ReefClaw discloses live-trading capability, exchange-credential storage, and remote instruction updates, which ClawHub flags for review (its linked security page has the details; VirusTotal reports the artifact clean). OpenClaw 2026.8.1+ shows that audit and continues once the capabilities are accepted; OpenClaw 2026.7.x still blocks the chat command on that label — there the user runs the `npx` line above, or `openclaw plugins install clawhub:@reefclaw/openclaw-plugin --acknowledge-clawhub-risk` in a terminal.
 
 Whatever the install path, **save the connection settings anyway** — the connector picks them up automatically the moment the plugin is running.
 

package/strategy/evaluator.d.ts

@@ -5,6 +5,10 @@ export interface SymbolFact {
     conditions: Record<string, boolean>;
     regime: string;
     regime_confidence: number;
+    /** Change-of-character block computed by the intel fact-computer (WS2,
+     *  docs/MARKET_ADAPTIVITY_PLAN.md §3). Absent on older intel builds or when
+     *  inputs were insufficient — consumers treat absence as "no signal". */
+    changeOfCharacter?: import('../signals/change-of-character.js').ChangeOfCharacter;
 }
 export interface ConditionConfig {
     type: string;

package/tools/close-position.js

@@ -317,9 +317,18 @@ export async function closePositionTool(args, deps) {
                         'Use get_wave9_status for a reversal authorization or operator_command for an emergency close.');
                 }
             }
+            // Thread the validated reason to the adapter as its CloseReason:
+            // 'operator_command' maps to 'operator' so an operator-driven close is
+            // never caught by the paper startup lockout (whose protective-exit
+            // carve-out keys on the reason — before this, the tool dropped the
+            // reason entirely and EVERY generic close arrived as discretionary).
+            // All other reasons are agent-discretionary by design and stay subject
+            // to the lockout; the rich reason still reaches the journal via
+            // close_reason, this only fixes the adapter-level class + metadata.
+            const adapterCloseReason = args.reason === 'operator_command' ? 'operator' : 'agent';
             return wave9ExitClaimed
                 ? deps.adapter.closePosition(args.symbol, 'wave9_signal_reversal')
-                : deps.adapter.closePosition(args.symbol);
+                : deps.adapter.closePosition(args.symbol, adapterCloseReason);
         };
         const closeWave9 = async () => {
             if (!wave9Lease)

package/tools/create-order.js

@@ -7,6 +7,10 @@ import { fetchCurrentPrice, fetchOrderBook, isError } from './helpers.js';
 import { validateCreateOrder, sanitizeRealizationRule, validateProtectiveGeometry } from './assessment-validation.js';
 import { preTradeRiskCheck, getDefaultPreTradeLimits, computeConsecutiveLosses } from '../risk/pre-trade-check.js';
 import { bracketsEnabled, loadBracketMode, loadBracketRequirements } from '../config/brackets-config.js';
+import { loadReentryCooldownMinutes, loadReentryCooldownMode, } from '../config/reentry-cooldown-config.js';
+import { resolveLossStreakSizingMode } from '../config/loss-streak-config.js';
+import { buildReentryCooldownRejection, evaluateReentryCooldown, } from './reentry-cooldown.js';
+import { normalizeBracketSymbol } from '../live/bracket-ledger.js';
 import { onCreateOrderFilled } from '../ingest/position-auto-capture.js';
 import { wave9ClientOrderId, } from '../wave9/live-execution-ledger.js';
 import { inspectWave9LiveSymbolOwnership, } from '../wave9/live-symbol-ownership.js';
@@ -1012,7 +1016,24 @@ export async function createOrderTool(args, deps) {
         }
         else {
             portfolio = await (livePortfolioPromise ?? buildPortfolioSnapshotFromAdapter(deps.adapter));
-            // In live mode, consecutive losses would come from intelligence DB — use 0 for now
+            // WS1 (docs/MARKET_ADAPTIVITY_PLAN.md §3): the graduated loss-streak
+            // sizing brake was fed a hardcoded 0 on live since the beginning. Real
+            // feed = trailing lossy closes on the live book from the ReentryTracker
+            // records. RC_LOSS_STREAK_SIZING = off | log (sizing unaffected) |
+            // enforce (DEFAULT since 2026-09-05 — live/paper parity restored after
+            // the log soak).
+            const streakMode = resolveLossStreakSizingMode();
+            if (streakMode !== 'off' && deps.autoCapture?.reentryTracker) {
+                const liveStreak = deps.autoCapture.reentryTracker.consecutiveLosses('live');
+                if (liveStreak > 0) {
+                    logger.info('loss-streak', `live consecutive losses=${liveStreak} (mode=${streakMode}` +
+                        (streakMode === 'log'
+                            ? ' — sizing UNAFFECTED; RC_LOSS_STREAK_SIZING=enforce applies the graduated reduction)'
+                            : ')'));
+                }
+                if (streakMode === 'enforce')
+                    consecutiveLosses = liveStreak;
+            }
         }
         // Bracket enforcement only applies in live mode when the feature is enabled.
         // Paper mode uses the stop-watcher and doesn't care about these flags.
@@ -1048,6 +1069,43 @@ export async function createOrderTool(args, deps) {
             const reasons = riskCheck.violations.map(v => v.message).join('; ');
             return rejectWave9Divergence(`Order REJECTED by risk gate [${riskCheck.drawdownZone} zone]: ${reasons}`, `generic_pretrade_divergence:${riskCheck.violations.map((v) => v.rule).join(',')}`);
         }
+        // ---- Re-entry cooldown gate (mode-laddered; ships 'off') ----
+        // Generic NEW entries only: wave9 has its own frozen admission policy,
+        // scale-ins and operator-approved proposal fires are exempt inside the
+        // evaluator, and this branch can only ever suppress a new entry — exits,
+        // closes, stops, and emergency paths never route through it. Mode resolves
+        // PER CALL (central → file → off) so a gate flip hot-applies, same as the
+        // exit gate. See tools/reentry-cooldown.ts for the measurement behind it.
+        let reentryCooldownEval;
+        if (!wave9Claimed) {
+            const rcMode = loadReentryCooldownMode();
+            if (rcMode !== 'off') {
+                const symbolKey = normalizeBracketSymbol(args.symbol);
+                reentryCooldownEval = evaluateReentryCooldown({
+                    symbol: args.symbol,
+                    mode: rcMode,
+                    tracker: deps.autoCapture?.reentryTracker,
+                    book: deps.adapter.isLive ? 'live' : 'paper',
+                    cooldownMinutes: loadReentryCooldownMinutes(),
+                    hasOpenPosition: portfolio.positions.some((p) => normalizeBracketSymbol(p.symbol) === symbolKey && Math.abs(p.quantity) > 0),
+                    isListenerFire: deps.entryClientOrderId != null,
+                });
+                if (reentryCooldownEval.triggered) {
+                    const detail = `${args.symbol} ${side}: lossy close ${reentryCooldownEval.minutesSinceLoss}m ago ` +
+                        `(window=${reentryCooldownEval.cooldownMinutes}m, mode=${rcMode}, ` +
+                        `loss_source=${reentryCooldownEval.lastLoss?.lossSource ?? 'unknown'})`;
+                    if (rcMode === 'shadow') {
+                        logger.info('reentry-cooldown', `WOULD BLOCK (shadow) ${detail}`);
+                    }
+                    else {
+                        logger.warn('reentry-cooldown', `${rcMode === 'enforce' ? 'BLOCKED' : 'WOULD BLOCK (observe)'} ${detail}`);
+                    }
+                    if (reentryCooldownEval.blocked) {
+                        return { error: buildReentryCooldownRejection(reentryCooldownEval, args.symbol) };
+                    }
+                }
+            }
+        }
         // Build position metadata from optional args (only if any metadata provided)
         // Sanitize numeric metadata — reject non-finite values, clamp ranges
         const num = (v) => typeof v === 'number' && Number.isFinite(v) ? v : undefined;
@@ -1055,9 +1113,20 @@ export async function createOrderTool(args, deps) {
             const n = num(v);
             return n != null ? Math.max(min, Math.min(max, n)) : undefined;
         };
+        // Journal-tag a TRIGGERED cooldown evaluation (shadow/observe fire-anyway cohort —
+        // the measurement rows the promote-to-enforce decision reads).
+        const reentryCooldownTag = reentryCooldownEval?.triggered
+            ? {
+                mode: reentryCooldownEval.mode,
+                minutesSinceLoss: reentryCooldownEval.minutesSinceLoss ?? 0,
+                cooldownMinutes: reentryCooldownEval.cooldownMinutes,
+                wouldBlock: true,
+            }
+            : undefined;
         const hasMetadata = args.mission_id || args.setup_type || args.thesis || args.target_price != null
             || args.regime || args.scorecard_verdict || args.confluence_score != null
-            || args.invalidation_price != null || args.realization_rule != null;
+            || args.invalidation_price != null || args.realization_rule != null
+            || reentryCooldownTag != null;
         const metadata = hasMetadata ? {
             missionId: args.mission_id,
             setupType: args.setup_type,
@@ -1076,6 +1145,7 @@ export async function createOrderTool(args, deps) {
             confluenceScore: clamp(args.confluence_score, 0, 10),
             invalidationPrice: num(args.invalidation_price),
             realizationRule: sanitizeRealizationRule(args.realization_rule),
+            reentryCooldown: reentryCooldownTag,
         } : undefined;
         // ---- Approval-mode branches ----
         // Both shadow and per_trade need full v2.10.0 metadata so the proposal is

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/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 evaluation logs at WARN (operator-visible).
+//   enforce — a triggered evaluation 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
@@ -189,10 +212,14 @@ export async function scanPairsTool(args, deps, decisionsDeps) {
     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'.
@@ -203,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);
@@ -223,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