@reefclaw/openclaw-plugin 0.1.23 → 0.1.25

package/simulator/exchange-simulator.js

@@ -12,6 +12,34 @@ import { fillMarketOrder, fillLimitOrder, parseSymbol } from './fill-engine.js';
 import { updateMfe } from '../mfe.js';
 import { computeInvalidationHit } from '../pinned-plan.js';
 const TAG = 'simulator';
+/** Canonical key for the per-symbol quote/orderbook caches and for matching a
+ *  ticker against stored positions/orders.
+ *
+ *  CCXT echoes the VENUE-UNIFIED symbol back from fetchTicker: ask Binance USDM
+ *  for 'ETH/USDT' and the ticker returns as 'ETH/USDT:USDT'. Positions and
+ *  orders, however, are stored under whatever form the caller opened them with,
+ *  so `lastTicker.get(position.symbol)` silently missed for every position held
+ *  in the un-suffixed form. The consequences were all silent:
+ *    - getPositions()/computeEquity() fell back to entryPrice, so the mark was
+ *      FROZEN at entry — the stop-watcher compared a frozen mark, never saw a
+ *      breach, and the position ran unprotected past its stop indefinitely;
+ *    - createOrder() threw 'No ticker data for X' on the market leg, so the
+ *      agent could not close by hand either (both automatic and manual exits
+ *      were dead at once);
+ *    - MFE, take-profit legs and resting-limit fills never advanced.
+ *  Keying both sides through this normalizer makes the caches format-agnostic,
+ *  which also repairs books already persisted with a mix of both forms.
+ *
+ *  Same regex as webapp/src/lib/symbols.ts normalizeSymbol and
+ *  plugin/src/venues/symbols.ts stripSettleSuffix — kept inline so the
+ *  simulator keeps its zero-import-for-hot-path shape. */
+export function tickerKey(symbol) {
+    return symbol.replace(/:[A-Z]+$/, '');
+}
+/** True when two symbols denote the same market regardless of settle suffix. */
+function sameMarket(a, b) {
+    return tickerKey(a) === tickerKey(b);
+}
 export class ExchangeSimulator extends EventEmitter {
     state;
     lastTicker = new Map();
@@ -112,7 +140,7 @@ export class ExchangeSimulator extends EventEmitter {
         const walletTotal = this.state.wallet[quote]?.total ?? 0;
         let positionEquity = 0;
         for (const pos of this.state.positions) {
-            const ticker = this.lastTicker.get(pos.symbol);
+            const ticker = this.lastTicker.get(tickerKey(pos.symbol));
             const mark = ticker?.last ?? pos.entryPrice;
             const entryNotional = pos.entryPrice * pos.quantity;
             const unrealized = pos.side === 'long'
@@ -182,10 +210,16 @@ export class ExchangeSimulator extends EventEmitter {
     }
     getPositions(symbol) {
         const positions = symbol
-            ? this.state.positions.filter(p => p.symbol === symbol)
+            ? this.state.positions.filter(p => sameMarket(p.symbol, symbol))
             : this.state.positions;
         return positions.map(p => {
-            const ticker = this.lastTicker.get(p.symbol);
+            const ticker = this.lastTicker.get(tickerKey(p.symbol));
+            // No quote for this symbol means we CANNOT mark this position. Falling
+            // back to entryPrice fabricates "flat since entry", which reads as a
+            // perfectly healthy position to every consumer — that is how a stop
+            // breach stayed invisible for 35h. Keep the fallback (callers need a
+            // number) but flag it so the stop-watcher can alarm instead of skipping.
+            const markPriceStale = ticker === undefined;
             const markPrice = ticker?.last ?? p.entryPrice;
             const notional = p.quantity * markPrice;
             const pnlMultiplier = p.side === 'long' ? 1 : -1;
@@ -200,6 +234,7 @@ export class ExchangeSimulator extends EventEmitter {
                 contractSize: 1,
                 entryPrice: p.entryPrice,
                 markPrice,
+                markPriceStale,
                 notional,
                 unrealizedPnl,
                 percentage,
@@ -233,7 +268,7 @@ export class ExchangeSimulator extends EventEmitter {
     }
     getOpenOrders(symbol) {
         const orders = symbol
-            ? this.state.openOrders.filter(o => o.symbol === symbol)
+            ? this.state.openOrders.filter(o => sameMarket(o.symbol, symbol))
             : this.state.openOrders;
         return orders.map(o => this.toCcxtOrder(o));
     }
@@ -244,10 +279,10 @@ export class ExchangeSimulator extends EventEmitter {
     // ---- Order book ----
     /** Cache the latest order book snapshot for a symbol. */
     updateOrderBook(symbol, orderbook) {
-        this.lastOrderBook.set(symbol, orderbook);
+        this.lastOrderBook.set(tickerKey(symbol), orderbook);
     }
     getLastOrderBook(symbol) {
-        return this.lastOrderBook.get(symbol);
+        return this.lastOrderBook.get(tickerKey(symbol));
     }
     // ---- Write operations (for tools) ----
     createOrder(symbol, side, type, amount, price, metadata, 
@@ -255,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');
@@ -294,7 +341,7 @@ export class ExchangeSimulator extends EventEmitter {
                 return this.executeMarketFill(order, referencePrice, metadata);
             }
             // Market orders fill immediately at current price
-            const ticker = this.lastTicker.get(symbol);
+            const ticker = this.lastTicker.get(tickerKey(symbol));
             if (!ticker) {
                 throw new Error(`No ticker data for ${symbol}. Call updateTicker() first.`);
             }
@@ -308,7 +355,7 @@ export class ExchangeSimulator extends EventEmitter {
         // Limit order — check if it crosses the current price. A stale quote must
         // not price an immediate cross-fill (same hazard as market fills); the
         // order RESTS instead and fills on the next fresh tick via updateTicker.
-        const ticker = this.lastTicker.get(symbol);
+        const ticker = this.lastTicker.get(tickerKey(symbol));
         if (ticker && this.quoteAgeMs(ticker) <= this.maxQuoteAgeMs() && this.shouldFillLimit(order, ticker.last)) {
             return this.executeLimitFill(order, ticker.last, metadata);
         }
@@ -341,7 +388,7 @@ export class ExchangeSimulator extends EventEmitter {
         const cancelled = [];
         const remaining = [];
         for (const order of this.state.openOrders) {
-            if (!symbol || order.symbol === symbol) {
+            if (!symbol || sameMarket(order.symbol, symbol)) {
                 order.status = 'canceled';
                 cancelled.push(order);
                 this.pendingOrderMetadata.delete(order.id);
@@ -364,7 +411,7 @@ export class ExchangeSimulator extends EventEmitter {
      *   else, which keeps the normal market-close path byte-identical.
      */
     closePosition(symbol, closeReason, referencePrice) {
-        const position = this.state.positions.find(p => p.symbol === symbol);
+        const position = this.state.positions.find(p => sameMarket(p.symbol, symbol));
         if (!position) {
             throw new Error(`No open position for ${symbol}`);
         }
@@ -375,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
@@ -387,7 +440,7 @@ export class ExchangeSimulator extends EventEmitter {
      *  and getPositions both read metadata.stopPrice, so a moved stop takes
      *  effect on the next watcher tick. Throws if there is no open position. (M9) */
     updatePositionMetadata(symbol, patch) {
-        const pos = this.state.positions.find(p => p.symbol === symbol);
+        const pos = this.state.positions.find(p => sameMarket(p.symbol, symbol));
         if (!pos) {
             throw new Error(`No open position for ${symbol}`);
         }
@@ -401,7 +454,7 @@ export class ExchangeSimulator extends EventEmitter {
     }
     // ---- Ticker updates (checks pending limit fills) ----
     updateTicker(ticker) {
-        this.lastTicker.set(ticker.symbol, ticker);
+        this.lastTicker.set(tickerKey(ticker.symbol), ticker);
         this.refreshMfeForSymbol(ticker.symbol, ticker.last);
         // MFE is refreshed FIRST so the peak this tick reached is recorded before a
         // target close reads it — otherwise every TP exit would understate its own
@@ -411,7 +464,7 @@ export class ExchangeSimulator extends EventEmitter {
         const toFill = [];
         const remaining = [];
         for (const order of this.state.openOrders) {
-            if (order.symbol === ticker.symbol && this.shouldFillLimit(order, ticker.last)) {
+            if (sameMarket(order.symbol, ticker.symbol) && this.shouldFillLimit(order, ticker.last)) {
                 toFill.push(order);
             }
             else {
@@ -449,7 +502,7 @@ export class ExchangeSimulator extends EventEmitter {
         }
     }
     getLastTicker(symbol) {
-        return this.lastTicker.get(symbol);
+        return this.lastTicker.get(tickerKey(symbol));
     }
     /**
      * Take-profit legs — the paper analog of the exchange-native
@@ -483,7 +536,7 @@ export class ExchangeSimulator extends EventEmitter {
         if (!Number.isFinite(price) || price <= 0)
             return;
         // Snapshot: closing mutates state.positions mid-iteration.
-        const candidates = this.state.positions.filter((p) => p.symbol === symbol);
+        const candidates = this.state.positions.filter((p) => sameMarket(p.symbol, symbol));
         for (const position of candidates) {
             const target = position.metadata?.targetPrice;
             if (target === undefined || !Number.isFinite(target) || target <= 0)
@@ -492,17 +545,20 @@ export class ExchangeSimulator extends EventEmitter {
             if (!breached)
                 continue;
             // Guard against a re-entrant tick firing a second close on the same
-            // symbol while the first is still settling.
-            if (this.takeProfitPending.has(symbol))
+            // symbol while the first is still settling. Keyed canonically so the
+            // guard still holds when the tick and the position disagree on suffix.
+            const pendingKey = tickerKey(position.symbol);
+            if (this.takeProfitPending.has(pendingKey))
                 continue;
-            this.takeProfitPending.add(symbol);
+            this.takeProfitPending.add(pendingKey);
             try {
-                logger.info(TAG, `TARGET REACHED: ${symbol} ${position.side} price=${price} target=${target} — closing (exchange_target)`);
+                logger.info(TAG, `TARGET REACHED: ${position.symbol} ${position.side} price=${price} target=${target} — closing (exchange_target)`);
                 // Target = decision price; the fill engine adds realistic adverse
-                // slippage on top (see the fill-convention note above).
-                const order = this.closePosition(symbol, 'exchange_target', target);
+                // slippage on top (see the fill-convention note above). Address the
+                // close with the POSITION's own symbol, never the ticker's form.
+                const order = this.closePosition(position.symbol, 'exchange_target', target);
                 this.emit('target_closed', {
-                    symbol,
+                    symbol: position.symbol,
                     side: position.side,
                     targetPrice: target,
                     markPrice: price,
@@ -514,10 +570,10 @@ export class ExchangeSimulator extends EventEmitter {
             catch (err) {
                 // Never let a failed protective close kill the tick loop — the next
                 // tick retries, and the position is still visible to the agent.
-                logger.error(TAG, `Target close failed for ${symbol}: ${formatError(err)}`);
+                logger.error(TAG, `Target close failed for ${position.symbol}: ${formatError(err)}`);
             }
             finally {
-                this.takeProfitPending.delete(symbol);
+                this.takeProfitPending.delete(pendingKey);
             }
         }
     }
@@ -530,7 +586,7 @@ export class ExchangeSimulator extends EventEmitter {
             return;
         let peakAdvanced = false;
         for (const p of this.state.positions) {
-            if (p.symbol !== symbol)
+            if (!sameMarket(p.symbol, symbol))
                 continue;
             const meta = { ...(p.metadata ?? {}) };
             const priorPeak = meta.mfePeakPrice;
@@ -602,7 +658,7 @@ export class ExchangeSimulator extends EventEmitter {
             const keptPeak = diskPeak === undefined
                 ? priorPeak
                 : (p.side === 'long' ? Math.max(priorPeak, diskPeak) : Math.min(priorPeak, diskPeak));
-            const mark = this.lastTicker.get(p.symbol)?.last ?? meta.originalEntryPrice ?? p.entryPrice;
+            const mark = this.lastTicker.get(tickerKey(p.symbol))?.last ?? meta.originalEntryPrice ?? p.entryPrice;
             const out = updateMfe({
                 side: p.side,
                 entryPrice: meta.originalEntryPrice ?? p.entryPrice,
@@ -671,7 +727,7 @@ export class ExchangeSimulator extends EventEmitter {
         const max = this.maxQuoteAgeMs();
         if (age <= max)
             return;
-        const pos = this.state.positions.find(p => p.symbol === symbol);
+        const pos = this.state.positions.find(p => sameMarket(p.symbol, symbol));
         // The order side reaching here is the one being filled — derive reduce vs
         // grow from the position side at the call site instead? The market path
         // calls this before fill with the order side unavailable; use position
@@ -696,8 +752,10 @@ export class ExchangeSimulator extends EventEmitter {
             : currentPrice >= order.price;
     }
     executeMarketFill(order, currentPrice, metadata) {
-        const position = this.state.positions.find(p => p.symbol === order.symbol) ?? null;
-        const orderbook = this.lastOrderBook.get(order.symbol) ?? null;
+        // Match canonically: a miss here would hand fillMarketOrder position=null,
+        // turning a CLOSE into a brand-new opposing position.
+        const position = this.state.positions.find(p => sameMarket(p.symbol, order.symbol)) ?? null;
+        const orderbook = this.lastOrderBook.get(tickerKey(order.symbol)) ?? null;
         const realistic = {
             orderbook,
             config: this.simulationConfig,
@@ -707,7 +765,7 @@ export class ExchangeSimulator extends EventEmitter {
         const result = fillMarketOrder(order, currentPrice, this.state.wallet, position, realistic);
         // Observability for issue #202: stamp the quote's age onto the fill's
         // execution-quality record so staleness is visible in trade history.
-        const tickerAtFill = this.lastTicker.get(order.symbol);
+        const tickerAtFill = this.lastTicker.get(tickerKey(order.symbol));
         if (result.executionQuality && tickerAtFill) {
             result.executionQuality.quoteAgeMs = this.quoteAgeMs(tickerAtFill);
         }
@@ -725,7 +783,7 @@ export class ExchangeSimulator extends EventEmitter {
         return ccxtOrder;
     }
     executeLimitFill(order, decisionPrice, metadata) {
-        const position = this.state.positions.find(p => p.symbol === order.symbol) ?? null;
+        const position = this.state.positions.find(p => sameMarket(p.symbol, order.symbol)) ?? null;
         const result = fillLimitOrder(order, this.state.wallet, position, this.simulationConfig, decisionPrice, metadata);
         const ccxtOrder = this.applyFillResult(result);
         const eq = result.executionQuality;
@@ -778,7 +836,9 @@ export class ExchangeSimulator extends EventEmitter {
         return ccxtOrder;
     }
     updatePosition(symbol, newPosition) {
-        const idx = this.state.positions.findIndex(p => p.symbol === symbol);
+        // Canonical match: an exact-compare miss here would append a DUPLICATE
+        // position row instead of replacing/removing the existing one.
+        const idx = this.state.positions.findIndex(p => sameMarket(p.symbol, symbol));
         if (newPosition) {
             if (idx >= 0) {
                 this.state.positions[idx] = newPosition;

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 eval, 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/audit-bracket-protection.js

@@ -566,13 +566,16 @@ async function auditHlLive(adapter) {
         };
     }
     const entries = [];
-    for (const p of activePositions) {
-        let symbolOrders;
-        try {
-            symbolOrders = await adapter.getOpenOrders(p.symbol);
-        }
-        catch (err) {
-            const m = formatError(err);
+    // Fan the per-symbol open-orders reads out (HL has no batched read; the
+    // serial loop cost N round-trips per heartbeat), then walk the results in
+    // the ORIGINAL position order — the first failing symbol still produces
+    // the identical error return, and no verdict logic changes.
+    const orderFetches = await Promise.allSettled(activePositions.map((pos) => adapter.getOpenOrders(pos.symbol)));
+    for (let i = 0; i < activePositions.length; i++) {
+        const p = activePositions[i];
+        const fetched = orderFetches[i];
+        if (fetched.status === 'rejected') {
+            const m = formatError(fetched.reason);
             logger.warn(TAG, `HL audit skipped — open orders unavailable for ${p.symbol}: ${m}`);
             return {
                 error: `Exchange data unavailable for ${p.symbol} (Hyperliquid open-orders fetch failed). ` +
@@ -580,6 +583,7 @@ async function auditHlLive(adapter) {
                     `close_position(reason='bracket_integrity') on the basis of this call. Underlying: ${m}`,
             };
         }
+        const symbolOrders = fetched.value;
         const ledgerRow = ledger.getBySymbol(p.symbol) ?? null;
         const rowNonTerminalWithCids = !!ledgerRow && !isTerminalBracketState(ledgerRow.state) && Boolean(ledgerRow.slCid || ledgerRow.tpCid);
         if (symbolOrders.length === 0 && rowNonTerminalWithCids) {

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

@@ -1,12 +1,16 @@
 // Tool: create_order — order execution with real price data + pre-trade risk gate
 // Readiness gate: BLOCKED unless adapter.readiness === 'READY'.
 import { createHash, randomUUID } from 'node:crypto';
-import { formatError } from '../logger.js';
+import { formatError, logger } from '../logger.js';
 import { getQuoteBalance, getQuoteWalletBalance } from '../balance-utils.js';
 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';
@@ -875,6 +879,7 @@ export async function createOrderTool(args, deps) {
     }
     // In paper mode, fetch latest ticker + order book for realistic fills
     let ticker = null;
+    let livePortfolioPromise;
     if (!deps.adapter.isLive) {
         const paperDeps = { binanceApi: deps.binanceApi, simulator: deps.adapter.getSimulator() };
         const [priceResult] = await Promise.all([
@@ -886,7 +891,14 @@ export async function createOrderTool(args, deps) {
         ticker = priceResult;
     }
     else {
-        // Live mode: fetch ticker for risk check reference price
+        // Live mode: the risk-gate portfolio snapshot (balance + positions) has
+        // no dependency on the ticker — start it here so the two exchange
+        // round-trips overlap; awaited at the risk check below. The catch-keeper
+        // only silences the unhandled rejection an early return would otherwise
+        // leave floating; the later await still surfaces the real error.
+        livePortfolioPromise = buildPortfolioSnapshotFromAdapter(deps.adapter);
+        livePortfolioPromise.catch(() => { });
+        // Fetch ticker for risk check reference price
         const lastPrice = await deps.adapter.getLastPrice(args.symbol);
         if (lastPrice != null) {
             ticker = {
@@ -1003,8 +1015,25 @@ export async function createOrderTool(args, deps) {
             consecutiveLosses = computeConsecutiveLosses(simulator.getState().tradeHistory);
         }
         else {
-            portfolio = await buildPortfolioSnapshotFromAdapter(deps.adapter);
-            // In live mode, consecutive losses would come from intelligence DB — use 0 for now
+            portfolio = await (livePortfolioPromise ?? buildPortfolioSnapshotFromAdapter(deps.adapter));
+            // 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.
@@ -1040,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;
@@ -1047,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 eval (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,
@@ -1068,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
@@ -1083,14 +1161,48 @@ export async function createOrderTool(args, deps) {
             typeof args.confluence_score === 'number');
         const proposalPathWired = !!(deps.proposalManager && deps.userId);
         const approvalMode = deps.approvalMode ?? 'off';
+        // per_trade + proposal path unwired: FAIL CLOSED.
+        //
+        // The operator asked for a human gate on every entry. If we can't deliver
+        // the proposal (no ingest token / no REEFCLAW_USER_ID), the honest failure
+        // is "no trade", not "trade without the gate". This branch previously fell
+        // through to the normal fire path so the agent was never trapped in an
+        // unfireable state — but that turned a misconfiguration into a live order
+        // the operator never approved, silently, with only a boot-time warning as
+        // the signal. A silent bypass of an explicitly-requested safety gate is the
+        // one outcome this feature exists to prevent (Locked Decision #2: never
+        // silent fire). Credentials drift for ordinary reasons — token rotation
+        // touches four files (docs/CLAUDE/token-rotation.md), and a freshly
+        // provisioned box can boot before they land — so this is a reachable state,
+        // not a theoretical one.
+        //
+        // Halting entries is the safe direction: exits, closes, stops and every
+        // operator emergency control are unaffected (they don't route through the
+        // approval branch), so a mis-wired box can still protect and unwind an open
+        // book — it just can't open new risk without the gate the operator asked
+        // for. Logged at ERROR on EVERY occurrence, not once at boot, so the signal
+        // is present at the time the trade is refused.
+        if (approvalMode === 'per_trade' && !proposalPathWired) {
+            logger.error('create-order', `approval.mode=per_trade but the proposal path is not wired — REFUSING to fire ` +
+                `${args.symbol} ${side} (fail-closed). Missing plugin connectionToken/WEBAPP_INGEST_TOKEN ` +
+                `and/or REEFCLAW_USER_ID. Restore the credentials, or set approval.mode=off to trade ` +
+                `autonomously again.`);
+            return {
+                error: 'Order refused: approval mode is per_trade but this box cannot deliver the proposal ' +
+                    'to the operator (missing connection token and/or REEFCLAW_USER_ID), so there is no ' +
+                    'way for the operator to approve it. Refusing to fire un-approved — this is fail-closed ' +
+                    'by design, not a transient error. Tell the operator: either restore the plugin ' +
+                    'connection credentials, or set approval.mode=off to resume autonomous trading. ' +
+                    'Do not retry until they confirm one of those. Closing positions, stops and brackets ' +
+                    'are unaffected.',
+            };
+        }
         // per_trade mode: propose and EARLY-RETURN. The agent's call doesn't fire;
         // the operator approves and ProposalDecisionListener fires via this same
         // tool with proposalManager omitted (which takes the real path below).
         //
-        // If proposalManager isn't wired (operator set approval.mode=per_trade in
-        // config but ingest creds aren't present), we fall through to the normal
-        // fire path — the startup warning is the operator's signal. We never trap
-        // the agent inside an unfireable per_trade branch.
+        // NOTE the listener's own fire passes NO approvalMode (defaults to 'off')
+        // and no proposalManager, so it never re-enters this branch.
         if (approvalMode === 'per_trade' && proposalPathWired) {
             if (!argsMetadataComplete) {
                 return {