@reefclaw/connect 0.1.36 → 0.1.38

package/assets/plugin/portfolio/directional-scoreboard.d.ts

@@ -0,0 +1,17 @@
+import type { ReentryExitRecord } from './reentry-tracker.js';
+export interface ScoreboardInputs {
+    /** Tracked open positions on the current book (state store, not exchange). */
+    openPositions: Array<{
+        side: 'long' | 'short';
+    }>;
+    /** Tracker exit records, oldest first (as stored). */
+    exitRecords: readonly ReentryExitRecord[];
+    book: 'paper' | 'live';
+    /** e.g. "BTC 4h −2.4% (−2.3×ATR)" — from the leader fact's changeOfCharacter. */
+    tapeLine?: string;
+    /** How many recent closes to summarize. */
+    lastN?: number;
+}
+/** Build the scoreboard line, or undefined when there is nothing to show
+ *  (no open positions AND no recent closes on this book). */
+export declare function buildDirectionalScoreboard(inputs: ScoreboardInputs): string | undefined;

package/assets/plugin/portfolio/directional-scoreboard.js

@@ -0,0 +1,71 @@
+// Directional scoreboard — WS2 of docs/MARKET_ADAPTIVITY_PLAN.md.
+//
+// One compact line of counter-evidence attached to the entry funnel
+// (scan_pairs): the book's current directional tilt, how the last N closes
+// per direction actually went, and what the market-leader tape did — the
+// three facts an anchored agent never sees together. Pure indication: it
+// never blocks or vetoes anything (that is the refuted-ledger's territory).
+//
+// Data sources are all local + free: the PositionStateStore (tracked open
+// positions — no exchange round-trip, so no HL address-budget cost) and the
+// ReentryTracker exit records (persisted; realizedR/realizedPnl where a
+// source had them). The tape line comes from the market leader's
+// change-of-character block on the intel facts the caller already fetched.
+const emptyStats = () => ({
+    wins: 0, losses: 0, unknown: 0, pnl: 0, pnlKnown: false, rSum: 0, rKnown: false,
+});
+function fmtDir(label, s) {
+    const n = s.wins + s.losses + s.unknown;
+    if (n === 0)
+        return undefined;
+    let out = `${label} ${s.wins}W/${s.losses}L${s.unknown > 0 ? `/${s.unknown}?` : ''}`;
+    if (s.rKnown)
+        out += ` ${s.rSum >= 0 ? '+' : ''}${Math.round(s.rSum * 100) / 100}R`;
+    else if (s.pnlKnown) {
+        const abs = Math.round(Math.abs(s.pnl) * 100) / 100;
+        out += ` ${s.pnl >= 0 ? '+' : '-'}$${abs}`;
+    }
+    return out;
+}
+/** Build the scoreboard line, or undefined when there is nothing to show
+ *  (no open positions AND no recent closes on this book). */
+export function buildDirectionalScoreboard(inputs) {
+    const lastN = inputs.lastN ?? 8;
+    const longs = inputs.openPositions.filter((p) => p.side === 'long').length;
+    const shorts = inputs.openPositions.filter((p) => p.side === 'short').length;
+    // Newest-first walk over this book's records (legacy untagged match either).
+    const recent = [];
+    for (let i = inputs.exitRecords.length - 1; i >= 0 && recent.length < lastN; i--) {
+        const r = inputs.exitRecords[i];
+        if (r.mode && r.mode !== inputs.book)
+            continue;
+        recent.push(r);
+    }
+    if (longs + shorts === 0 && recent.length === 0)
+        return undefined;
+    const stats = { long: emptyStats(), short: emptyStats() };
+    for (const r of recent) {
+        const s = stats[r.side];
+        if (r.wasLoss === true)
+            s.losses++;
+        else if (r.wasLoss === false)
+            s.wins++;
+        else
+            s.unknown++;
+        if (typeof r.realizedPnl === 'number' && Number.isFinite(r.realizedPnl)) {
+            s.pnl += r.realizedPnl;
+            s.pnlKnown = true;
+        }
+        if (typeof r.realizedR === 'number' && Number.isFinite(r.realizedR)) {
+            s.rSum += r.realizedR;
+            s.rKnown = true;
+        }
+    }
+    const parts = [`book: ${longs}L/${shorts}S open`];
+    const closeBits = [fmtDir('longs', stats.long), fmtDir('shorts', stats.short)].filter((v) => v !== undefined);
+    if (closeBits.length > 0)
+        parts.push(`last ${recent.length} closes: ${closeBits.join(', ')}`);
+    if (inputs.tapeLine)
+        parts.push(`tape: ${inputs.tapeLine}`);
+    return parts.join(' · ');
+}

package/assets/plugin/portfolio/reentry-tracker.d.ts

@@ -4,8 +4,24 @@ export interface ReentryExitRecord {
     /** setup_type / strategy name from the entry metadata, when known. */
     setupType?: string;
     side: 'long' | 'short';
-    /** Whether the closed trade realized a loss (drives the stronger caution). */
+    /** Whether the closed trade realized a loss (drives the stronger caution
+     *  and arms the reentryCooldown gate). */
     wasLoss?: boolean;
+    /** Where the wasLoss sign came from, for auditing sign-accuracy before the
+     *  cooldown gate is promoted past shadow: engine-exact ('paper_engine',
+     *  'ws_fill') vs the agent's own close assessment ('assessment_r'). */
+    lossSource?: 'paper_engine' | 'assessment_r' | 'ws_fill';
+    /** Trading book at close time. The cooldown gate filters to the current
+     *  book so a paper loss can't cool down a live entry after a mode flip.
+     *  Legacy records (absent) match either book — they age out of any
+     *  realistic cooldown window within the hour anyway. */
+    mode?: 'paper' | 'live';
+    /** Realized R at close where a source had it (agent assessment on live
+     *  tool-closes). Feeds the WS2 directional scoreboard. */
+    realizedR?: number;
+    /** Realized net PnL (quote ccy) where engine/exchange-exact (paper engine,
+     *  WS bracket fills). Feeds the WS2 directional scoreboard. */
+    realizedPnl?: number;
     closedAtMs: number;
 }
 /** Signal-bar duration for a strategy/setup name. Name-suffix inference:
@@ -26,6 +42,27 @@ export declare class ReentryTracker {
     /** Most recent exit for (symbol[, setup]). A setup-specific record wins over
      *  a symbol-only match so multi-strategy books get precise cautions. */
     lastExit(symbol: string, setupType?: string): ReentryExitRecord | undefined;
+    /** Most recent LOSSY exit for `symbol` within `windowMs`, or undefined.
+     *  Feeds the reentryCooldown gate (evidence 2026-09-02: 58 re-entries within
+     *  60m of a same-symbol losing close ran −0.077R mean vs +0.090R baseline).
+     *  Any direction, any setup — the measured pathology is symbol churn, not
+     *  setup churn. `mode` filters to the current trading book; records without
+     *  a mode tag (pre-upgrade) match either book. */
+    lastLossyExit(symbol: string, windowMs: number, opts?: {
+        mode?: 'paper' | 'live';
+        nowMs?: number;
+    }): ReentryExitRecord | undefined;
+    /** Trailing consecutive LOSSY closes on `book`, newest first, across ALL
+     *  symbols — the live feed for the graduated loss-streak sizing brake in
+     *  preTradeRiskCheck (WS1, docs/MARKET_ADAPTIVITY_PLAN.md §3; live was fed a
+     *  hardcoded 0 since the beginning while paper computed it from engine
+     *  history). Semantics: a WIN breaks the streak, and so does an
+     *  UNKNOWN-outcome record (wasLoss undefined) — unknown is never counted as
+     *  a loss, and stopping there under-counts, which only makes the brake
+     *  gentler. Records from the OTHER book are skipped entirely (a paper loss
+     *  neither extends nor breaks a live streak); legacy untagged records match
+     *  either book, same as lastLossyExit. */
+    consecutiveLosses(book: 'paper' | 'live'): number;
     /** Structured caution when (symbol, strategy) was already traded within the
      *  current signal bar. Undefined = no caution. Pure indication (issue #204):
      *  the agent decides; nothing here blocks an order. */

package/assets/plugin/portfolio/reentry-tracker.js

@@ -98,6 +98,55 @@ export class ReentryTracker {
         }
         return bySetup ?? bySymbol;
     }
+    /** Most recent LOSSY exit for `symbol` within `windowMs`, or undefined.
+     *  Feeds the reentryCooldown gate (evidence 2026-09-02: 58 re-entries within
+     *  60m of a same-symbol losing close ran −0.077R mean vs +0.090R baseline).
+     *  Any direction, any setup — the measured pathology is symbol churn, not
+     *  setup churn. `mode` filters to the current trading book; records without
+     *  a mode tag (pre-upgrade) match either book. */
+    lastLossyExit(symbol, windowMs, opts) {
+        const key = normalizeBracketSymbol(symbol);
+        const now = opts?.nowMs ?? Date.now();
+        for (let i = this.records.length - 1; i >= 0; i--) {
+            const r = this.records[i];
+            if (r.symbol !== key)
+                continue;
+            if (r.wasLoss !== true)
+                continue;
+            if (opts?.mode && r.mode && r.mode !== opts.mode)
+                continue;
+            const ageMs = now - r.closedAtMs;
+            // Tolerate small clock skew on exchange timestamps (up to 60s in the
+            // future still counts as "just closed").
+            if (ageMs >= -60_000 && ageMs <= windowMs)
+                return r;
+        }
+        return undefined;
+    }
+    /** Trailing consecutive LOSSY closes on `book`, newest first, across ALL
+     *  symbols — the live feed for the graduated loss-streak sizing brake in
+     *  preTradeRiskCheck (WS1, docs/MARKET_ADAPTIVITY_PLAN.md §3; live was fed a
+     *  hardcoded 0 since the beginning while paper computed it from engine
+     *  history). Semantics: a WIN breaks the streak, and so does an
+     *  UNKNOWN-outcome record (wasLoss undefined) — unknown is never counted as
+     *  a loss, and stopping there under-counts, which only makes the brake
+     *  gentler. Records from the OTHER book are skipped entirely (a paper loss
+     *  neither extends nor breaks a live streak); legacy untagged records match
+     *  either book, same as lastLossyExit. */
+    consecutiveLosses(book) {
+        let n = 0;
+        for (let i = this.records.length - 1; i >= 0; i--) {
+            const r = this.records[i];
+            if (r.mode && r.mode !== book)
+                continue;
+            if (r.wasLoss === true) {
+                n++;
+                continue;
+            }
+            break; // win or unknown outcome ends the trailing streak
+        }
+        return n;
+    }
     /** Structured caution when (symbol, strategy) was already traded within the
      *  current signal bar. Undefined = no caution. Pure indication (issue #204):
      *  the agent decides; nothing here blocks an order. */

package/assets/plugin/signals/change-of-character.d.ts

@@ -0,0 +1,38 @@
+/** 30m move ≥ this ×ATR(1h) ⇒ 'shock'. */
+export declare const SHOCK_ATR_MULT_30M = 2;
+/** 4h tape opposing a directional regime label by ≥ this ×ATR(1h) ⇒ 'regime_tape_disagreement'. */
+export declare const DISAGREEMENT_ATR_MULT_4H = 2;
+export type ChangeOfCharacterFlag = 'shock' | 'regime_tape_disagreement';
+export interface ChangeOfCharacter {
+    /** |price now − close ~30m ago| ÷ ATR(1h). */
+    shock30mAtr: number;
+    /** (max high − min low) over the last ~30m ÷ ATR(1h) — catches a spike-and-revert the close-to-close move misses. */
+    range30mAtr: number;
+    /** % return vs the close ~1h ago. */
+    return1hPct: number;
+    /** % return vs the close ~4h ago. */
+    return4hPct: number;
+    /** Signed (price now − close ~4h ago) ÷ ATR(1h) — the tape the regime label must answer to. */
+    tape4hAtr: number;
+    /** ATR(1h) as % of price — the volatility yardstick the multiples are in. */
+    atrPct: number;
+    flags: ChangeOfCharacterFlag[];
+    /** Agent-facing one-liner. Present ONLY when a flag fired — silence stays silent. */
+    summary?: string;
+}
+interface BarLike {
+    high: number;
+    low: number;
+    close: number;
+}
+export interface ChangeOfCharacterInputs {
+    /** 5m bars, oldest first (≥7 required). */
+    ohlcv5m: BarLike[];
+    /** 1h bars, oldest first (≥5 required). */
+    ohlcv1h: BarLike[];
+    atr14: number;
+    currentPrice: number;
+    regime: string;
+}
+export declare function computeChangeOfCharacter(inputs: ChangeOfCharacterInputs): ChangeOfCharacter | undefined;
+export {};

package/assets/plugin/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/assets/plugin/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/assets/plugin/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/assets/plugin/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/assets/plugin/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/assets/plugin/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/assets/plugin/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/assets/plugin/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;