@reefclaw/openclaw-plugin 0.1.23 → 0.1.25

package/config/gate-store.js

@@ -30,11 +30,15 @@ class GateStore {
     apply(gates) {
         const next = gates ?? {};
         const changed = next.exitGate !== this.gates.exitGate ||
-            next.positionReviewMode !== this.gates.positionReviewMode;
+            next.positionReviewMode !== this.gates.positionReviewMode ||
+            next.approvalMode !== this.gates.approvalMode ||
+            next.reentryCooldown !== this.gates.reentryCooldown;
         this.gates = { ...next };
         if (changed) {
             logger.info(TAG, `applied central gates: exitGate=${next.exitGate ?? UNSET} ` +
-                `positionReviewMode=${next.positionReviewMode ?? UNSET}`);
+                `positionReviewMode=${next.positionReviewMode ?? UNSET} ` +
+                `approvalMode=${next.approvalMode ?? UNSET} ` +
+                `reentryCooldown=${next.reentryCooldown ?? UNSET}`);
         }
     }
     /** The central exitGate mode, or null when central has no value (or the
@@ -51,6 +55,26 @@ class GateStore {
             return null;
         return this.gates.positionReviewMode ?? null;
     }
+    /** The central approval.mode, or null when central has no value (or the
+     *  kill-switch is on) — null tells the reader to fall back to the file.
+     *
+     *  ★ Central can only ever say 'off' or 'per_trade'. It cannot enable shadow
+     *  telemetry (that's the local APPROVAL_SHADOW_MODE env flag) and it cannot
+     *  weaken the hardcoded safety floor — per_trade only ADDS a gate, and 'off'
+     *  is the pre-existing autonomous behaviour, so neither value can leave a
+     *  position unprotected. */
+    getApprovalMode() {
+        if (!centralGatesEnabled())
+            return null;
+        return this.gates.approvalMode ?? null;
+    }
+    /** The central reentryCooldown mode, or null when central has no value (or
+     *  the kill-switch is on) — null tells the reader to fall back to the file. */
+    getReentryCooldown() {
+        if (!centralGatesEnabled())
+            return null;
+        return this.gates.reentryCooldown ?? null;
+    }
     /** Test-only. */
     __reset() {
         this.gates = {};

package/config/loss-streak-config.d.ts

@@ -0,0 +1,2 @@
+export type LossStreakSizingMode = 'off' | 'log' | 'enforce';
+export declare function resolveLossStreakSizingMode(): LossStreakSizingMode;

package/config/loss-streak-config.js

@@ -0,0 +1,33 @@
+// WS1 (docs/MARKET_ADAPTIVITY_PLAN.md §3) — mode resolver for the LIVE
+// loss-streak sizing brake feed.
+//
+// preTradeRiskCheck has always had a graduated loss-streak brake (0.5× /
+// 0.25× position size at the operator-tunable lossStreakHalfSize /
+// lossStreakQuarterSize thresholds — never a hard block), but live fed it a
+// hardcoded consecutiveLosses=0 ("would come from intelligence DB — use 0
+// for now"). The real feed now comes from the ReentryTracker exit records
+// (wasLoss + book tag, persisted).
+//
+// Env RC_LOSS_STREAK_SIZING:
+//   'enforce' (DEFAULT since 2026-09-05) — feed the real streak to the risk
+//                          check; the graduated size reduction applies on
+//                          live exactly as it always has on paper. Promoted
+//                          from 'log' after the pre-registered soak: 3 days
+//                          of clean streak logs (1→3 tracked + reset
+//                          correctly) and an 18/18 loss-sign agreement audit
+//                          between the agent's r_multiple_at_close and DB
+//                          realized_r.
+//   'log'               — compute + log on entries; sizing UNAFFECTED
+//                          (riskCheck still sees 0). The rollout soak mode.
+//   'off'               — no compute, no log; byte-identical to the
+//                          pre-WS1 path (kill-switch).
+//
+// Deliberately env-based (not the central gate channel): it is a
+// live/paper-parity bug fix on a risk-reduction mechanism, not a new policy
+// ladder — and its only enforce-direction effect is SMALLER size.
+export function resolveLossStreakSizingMode() {
+    const raw = (process.env.RC_LOSS_STREAK_SIZING ?? '').toLowerCase();
+    if (raw === 'off' || raw === 'log')
+        return raw;
+    return 'enforce';
+}

package/config/plugin-config-io.d.ts

@@ -197,6 +197,25 @@ export interface PluginConfigFile {
     stopWatcher?: {
         intervalMs?: number;
     };
+    /** Re-entry cooldown gate — blocks (mode-laddered) a NEW create_order entry
+     *  on a symbol whose last close within `minutes` was a LOSS. See
+     *  plugin/src/tools/reentry-cooldown.ts for the evidence + semantics.
+     *
+     *  mode='off' (default)  — gate never runs; behaviour identical to today.
+     *  mode='shadow'         — gate runs; verdict logged + tagged into
+     *                           position_entries.metadata.reentry_cooldown;
+     *                           the order always fires.
+     *  mode='observe'        — as shadow, but a triggered verdict logs at WARN.
+     *  mode='enforce'        — triggered verdict hard-rejects create_order.
+     *
+     *  `mode` here is the LOCAL fallback — once the central gate
+     *  (agent_config.gates.reentryCooldown) is set, central rules (kill-switch
+     *  RC_CENTRAL_GATES=off). `minutes` is local-only (default 60, clamped
+     *  5–1440). */
+    reentryCooldown?: {
+        mode?: 'off' | 'shadow' | 'observe' | 'enforce';
+        minutes?: number;
+    };
     [extra: string]: unknown;
 }
 export declare function defaultConfigPath(): string;

package/config/plugin-config-io.js

@@ -10,7 +10,7 @@
 // operator-only tool gated on dashboard provenance (verifyOperatorProvenance,
 // audit F12) — the agent cannot reach these writes conversationally. The file
 // is the plugin's OWN config store; nothing here touches OpenClaw's config.
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { logger } from '../logger.js';
@@ -82,17 +82,39 @@ export function loadMicroLiveConfig(path) {
     catch { /* best-effort — adapter default applies */ }
     return undefined;
 }
+// mtime(ns)+size memo: several hot paths re-read this file per tool call
+// (approval mode, bracket mode/requirements, exit gate, review mode, the
+// microstructure flag × N symbols on the review path). A write always bumps
+// mtime, so the documented per-call hot-reload semantics are preserved
+// exactly — an unchanged file just costs one stat instead of read+parse.
+// structuredClone on both sides keeps today's fresh-object-per-call contract.
+const readMemo = new Map();
 /** Read the config file. Returns `{}` if the file doesn't exist.
  *  Throws if the file exists but is unreadable or not valid JSON — callers
  *  should treat that as an abort signal, not silently overwrite. */
 export function readPluginConfig(path = defaultConfigPath()) {
-    if (!existsSync(path))
+    if (!existsSync(path)) {
+        readMemo.delete(path);
         return {};
+    }
+    let stat;
+    try {
+        const s = statSync(path, { bigint: true });
+        stat = { mtimeNs: s.mtimeNs, size: s.size };
+        const hit = readMemo.get(path);
+        if (hit && hit.mtimeNs === stat.mtimeNs && hit.size === stat.size) {
+            return structuredClone(hit.parsed);
+        }
+    }
+    catch { /* stat raced a delete — fall through to the plain read */ }
     const raw = readFileSync(path, 'utf-8');
     const parsed = JSON.parse(raw);
     if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed)) {
         throw new Error(`plugin-config.json root is not an object`);
     }
+    if (stat) {
+        readMemo.set(path, { ...stat, parsed: structuredClone(parsed) });
+    }
     return parsed;
 }
 /** Apply a patch on top of the existing file and write atomically.

package/config/reentry-cooldown-config.d.ts

@@ -0,0 +1,7 @@
+import { type PluginConfigFile } from './plugin-config-io.js';
+import type { ReentryCooldownMode } from '../tools/reentry-cooldown.js';
+export declare const DEFAULT_REENTRY_COOLDOWN_MINUTES = 60;
+export declare function getReentryCooldownMode(config?: PluginConfigFile): ReentryCooldownMode;
+export declare function loadReentryCooldownMode(): ReentryCooldownMode;
+export declare function getReentryCooldownMinutes(config?: PluginConfigFile): number;
+export declare function loadReentryCooldownMinutes(): number;

package/config/reentry-cooldown-config.js

@@ -0,0 +1,59 @@
+// Feature-flag readers for the re-entry cooldown gate (create_order).
+//
+// Mode default 'off' so the gate ships dead-code; the cooldown window default
+// (60 min) matches the 2026-09-02 measurement window that motivated the gate.
+// Mode resolution follows the exitGate pattern (config-service slice 2):
+//
+//     central (agent_config.gates.reentryCooldown via gate-store)
+//       → plugin-config.json reentryCooldown.mode
+//       → 'off'
+//
+// create_order reads the mode PER CALL, so a dashboard/API flip via
+// scripts/enable-reentry-cooldown.py hot-applies within one config poll —
+// no restart. Kill-switch RC_CENTRAL_GATES=off hands control back to the
+// local file. The minutes knob is LOCAL-only (mechanism tunable, not a
+// ladder) — central carries only the mode.
+import { readPluginConfig } from './plugin-config-io.js';
+import { gateStore } from './gate-store.js';
+const VALID_MODES = new Set([
+    'off',
+    'shadow',
+    'observe',
+    'enforce',
+]);
+export const DEFAULT_REENTRY_COOLDOWN_MINUTES = 60;
+const MIN_COOLDOWN_MINUTES = 5;
+const MAX_COOLDOWN_MINUTES = 1440;
+export function getReentryCooldownMode(config) {
+    const raw = config?.reentryCooldown?.mode;
+    if (typeof raw === 'string' && VALID_MODES.has(raw)) {
+        return raw;
+    }
+    return 'off';
+}
+export function loadReentryCooldownMode() {
+    const central = gateStore.getReentryCooldown();
+    if (central)
+        return central;
+    try {
+        return getReentryCooldownMode(readPluginConfig());
+    }
+    catch {
+        return 'off';
+    }
+}
+export function getReentryCooldownMinutes(config) {
+    const raw = config?.reentryCooldown?.minutes;
+    if (typeof raw === 'number' && Number.isFinite(raw)) {
+        return Math.max(MIN_COOLDOWN_MINUTES, Math.min(MAX_COOLDOWN_MINUTES, raw));
+    }
+    return DEFAULT_REENTRY_COOLDOWN_MINUTES;
+}
+export function loadReentryCooldownMinutes() {
+    try {
+        return getReentryCooldownMinutes(readPluginConfig());
+    }
+    catch {
+        return DEFAULT_REENTRY_COOLDOWN_MINUTES;
+    }
+}

package/http/keepalive-fetch.d.ts

@@ -0,0 +1,5 @@
+export type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;
+/** Drop-in fetch with connection keep-alive; falls back to global fetch when
+ *  undici is unavailable, and defers to globalThis.fetch whenever it has been
+ *  replaced (mocks/instrumentation). */
+export declare function keepAliveFetch(url: string, init?: RequestInit): Promise<Response>;

package/http/keepalive-fetch.js

@@ -0,0 +1,50 @@
+// Keep-alive HTTP for the plugin's intel/webapp clients.
+//
+// Node's built-in fetch closes idle sockets after undici's 4s default, and the
+// gap between two agent tool calls is LLM think-time (seconds to tens of
+// seconds) — so every intel/webapp call was paying a fresh TCP+TLS handshake
+// (~2 RTTs) before any server work started. A dedicated undici Agent with a
+// 60s idle timeout holds the connection across those gaps.
+//
+// undici loads via createRequire (same rule as CCXT — see
+// docs/CLAUDE/plugin-integration.md) and the whole module FAILS OPEN to the
+// global fetch: dist-only overlay deploys land on boxes whose node_modules
+// predate this dependency, and a missing package must degrade to today's
+// behaviour, never crash the connector.
+import { createRequire } from 'node:module';
+// Captured at module load. When someone REPLACES globalThis.fetch later
+// (vitest fetch mocks, tracing wrappers), keepAliveFetch honors the
+// replacement instead of undici — otherwise every fetch-stubbing test (and
+// any legitimate instrumentation) would be silently bypassed onto the real
+// network.
+const nativeFetch = globalThis.fetch;
+let cached;
+function build() {
+    try {
+        const req = createRequire(import.meta.url);
+        const undici = req('undici');
+        const dispatcher = new undici.Agent({
+            keepAliveTimeout: 60_000,
+            keepAliveMaxTimeout: 300_000,
+            connections: 16,
+        });
+        // undici's own fetch + Agent are used together: passing an npm-undici
+        // dispatcher to Node's built-in fetch can fail an instanceof check against
+        // the internal undici copy.
+        return (url, init) => undici.fetch(url, { ...init, dispatcher });
+    }
+    catch {
+        return (url, init) => fetch(url, init);
+    }
+}
+/** Drop-in fetch with connection keep-alive; falls back to global fetch when
+ *  undici is unavailable, and defers to globalThis.fetch whenever it has been
+ *  replaced (mocks/instrumentation). */
+export function keepAliveFetch(url, init) {
+    if (globalThis.fetch !== nativeFetch) {
+        return globalThis.fetch(url, init);
+    }
+    if (!cached)
+        cached = build();
+    return cached(url, init);
+}

package/index.js

@@ -989,7 +989,10 @@ const paperTradingPlugin = {
         // gateway process must reload it before serving HTTP API calls.
         const reloadState = () => {
             try {
-                const fresh = stateManager.loadSync();
+                // Skips the full read+parse (and replaceState) when the on-disk file
+                // hasn't changed since the last load — this runs on every paper-mode
+                // tool call and the file grows with trade history.
+                const fresh = stateManager.loadSyncIfChanged();
                 if (fresh) {
                     simulator.replaceState(fresh);
                 }
@@ -1293,11 +1296,32 @@ const paperTradingPlugin = {
         // rows while collecting real ones). See docs/APPROVAL_MODE_DESIGN.md §12.
         const approvalShadowEnabled = (process.env.APPROVAL_SHADOW_MODE ?? '').trim() === '1';
         const resolveApprovalMode = () => {
-            try {
-                if (readPluginConfig().approval?.mode === 'per_trade')
-                    return 'per_trade';
+            // Precedence (config-service slice 4, mirrors loadExitGateMode /
+            // loadPositionReviewMode):
+            //
+            //   central (agent_config.gates.approvalMode) → plugin-config.json →
+            //   APPROVAL_SHADOW_MODE env → 'off'
+            //
+            // Central is enum-validated plugin-side (agent-config-client
+            // validateGates) and can only ever say 'off' | 'per_trade' — it cannot
+            // enable shadow telemetry and cannot weaken the safety floor. Kill-switch
+            // RC_CENTRAL_GATES=off makes the store report null and the file rules
+            // again. Read per call, so a dashboard flip applies within one poll
+            // (~60 s) with no restart.
+            const central = gateStore.getApprovalMode();
+            if (central === 'per_trade')
+                return 'per_trade';
+            if (central !== 'off') {
+                // No central value — fall back to the local file.
+                try {
+                    if (readPluginConfig().approval?.mode === 'per_trade')
+                        return 'per_trade';
+                }
+                catch { /* config unreadable — env-only fallback below */ }
             }
-            catch { /* config unreadable — env-only fallback below */ }
+            // Central 'off' still permits local shadow telemetry: shadow does not
+            // change trading behaviour (the order fires either way), it only writes
+            // an extra row, and the env flag is the operator's own local choice.
             return approvalShadowEnabled ? 'shadow' : 'off';
         };
         // Proposal manager + listener credentials: built whenever ingest
@@ -1327,8 +1351,18 @@ const paperTradingPlugin = {
                     logger.info(TAG, `Approval wiring active (mode=${bootApprovalMode}) → ${ingestBaseUrl} (userId=${reefclawUserId.slice(0, 8)}…)`);
                 }
             }
+            else if (bootApprovalMode === 'per_trade') {
+                // FAIL-CLOSED state: create_order will REFUSE every new entry until the
+                // credentials are restored or approval.mode is set back to off. Loud at
+                // boot AND at each refusal (create-order.ts) — a boot-only signal is how
+                // this used to go unnoticed while orders fired without the gate.
+                logger.error(TAG, `approval mode=per_trade but ingest token / REEFCLAW_USER_ID missing — proposals CANNOT ` +
+                    `reach the operator, so create_order will REFUSE every new entry (fail-closed). ` +
+                    `Restore the plugin connectionToken/WEBAPP_INGEST_TOKEN + REEFCLAW_USER_ID, or set ` +
+                    `approval.mode=off. Exits, stops, brackets and operator controls are unaffected.`);
+            }
             else if (bootApprovalMode !== 'off') {
-                logger.warn(TAG, `approval mode=${bootApprovalMode} but ingest token / REEFCLAW_USER_ID missing — proposal path disabled (orders fire directly)`);
+                logger.warn(TAG, `approval mode=${bootApprovalMode} but ingest token / REEFCLAW_USER_ID missing — shadow telemetry disabled (orders fire directly, as in off mode)`);
             }
         }
         // ---- Create exchange adapter based on trading mode ----
@@ -1351,12 +1385,21 @@ const paperTradingPlugin = {
                 // Micro-live cap — same loader every runtime reconnect uses
                 // (buildAdapter), so boot and reconnect can never disagree (F8).
                 const microLiveConfig = loadMicroLiveConfig();
-                // Bracket-orders feature flag read from plugin-config at construction time.
-                // Default 'off' keeps legacy stop-watcher behaviour while the feature rolls out.
+                // Bracket-orders feature flag read from plugin-config at construction
+                // time. Since 2026-08-25 (E2E audit #3) the default on a live-Binance
+                // box is 'enforce' — the old 'off' default meant a fresh npx install
+                // flipped to live traded genuinely naked (no exchange stops AND the
+                // mandatory-stop gate skipped, since it is wired behind
+                // bracketsEnabled). An 'off' here can only be an explicit override.
                 const bracketMode = loadBracketMode();
                 if (bracketMode !== 'off') {
                     logger.info(TAG, `Bracket orders enabled in mode=${bracketMode}`);
                 }
+                else {
+                    logger.warn(TAG, `LIVE Binance with brackets.mode='off' (explicit config override) — NO exchange-side ` +
+                        `stops; positions rely on the software watcher alone and the mandatory-stop ` +
+                        `pre-trade gate is OFF. The dashboard readiness banner will show this red.`);
+                }
                 // User-data WebSocket stream flag — same mode-ladder pattern as brackets.
                 // Default 'off' keeps REST polling authoritative. Phase 1 ships dead-code;
                 // the flag flip to 'shadow' / 'observe' / 'enforce' is operator-driven.
@@ -1384,6 +1427,11 @@ const paperTradingPlugin = {
                             // F26: same wiring object as the Binance arm — the SIGTERM
                             // drain covers both venues because it drains this client.
                             tradeIngest,
+                            // Journal close capture (close-bypass fix, HL arm): without
+                            // this, every bracket SL/TP fill leaked as status='open'
+                            // until the reconciler healed it reason-less (50% of wisekid
+                            // 30d closes were reconciler_observed_flat).
+                            autoCapture,
                         },
                     }
                     : {
@@ -1887,6 +1935,14 @@ const paperTradingPlugin = {
                     pollIntervalMs: approvalCfg?.pollIntervalMs ?? 3_000,
                 });
             },
+            // The approval path just went away (mode flipped off, or live→PAPER).
+            // Anything still pending is now un-fireable but still shows an Approve
+            // button — cancel it rather than leave the operator a dead control.
+            onApprovalPathDisabled: async () => {
+                if (!proposalManagerCtx)
+                    return;
+                await proposalManagerCtx.manager.cancelAll(proposalManagerCtx.userId, 'mode_disabled');
+            },
         });
         runtime.setOnAdapterSwapped((a) => { void approvalLifecycle.onAdapterSwapped(a); });
         // Boot application — the same path every later swap takes.
@@ -2581,6 +2637,11 @@ const paperTradingPlugin = {
                     decisionsClient: positionDecisionsClient,
                     userId: positionDecisionsUserId,
                     reentryTracker,
+                    // WS2 directional scoreboard (docs/MARKET_ADAPTIVITY_PLAN.md §3):
+                    // tracked positions from the state store (no exchange round-trip)
+                    // + book resolved per call so a paper↔live flip follows.
+                    openPositions: () => positionStateStore.getAll().map((e) => ({ side: e.side })),
+                    book: () => (runtime.adapter.isLive ? 'live' : 'paper'),
                 })),
             },
             {
@@ -2878,6 +2939,14 @@ const paperTradingPlugin = {
             venue,
             publicApi: hlPublicApi ?? binanceApi,
             toolCount: toolNames.length,
+            // live_stop_protection (E2E audit #3): what would stop a losing live
+            // position. Deferred closure over the runtime so paper↔live flips and
+            // adapter swaps surface on the next 5-min report without a restart.
+            resolveStopProtection: () => ({
+                tradingMode: runtime.mode,
+                venueEnforced: runtime.adapter.bracketsAlwaysEnforced === true,
+                bracketMode: loadBracketMode(),
+            }),
         });
         maybeStartConnectorSupervisor();
     },

package/ingest/position-auto-capture.js

@@ -19,7 +19,7 @@
 // that hooks into the WS-ingest pipeline (see POSITION_DECISION_JOURNAL_PLAN
 // §5.1 for the longer-term design).
 import { logger } from '../logger.js';
-import { isBracketCid } from '../live/bracket-id.js';
+import { isBracketClientId, parseBracketClientId } from '../live/bracket-id.js';
 import { normalizeBracketSymbol } from '../live/bracket-ledger.js';
 import { fillPriceFromOrder } from '../live/fill-price.js';
 import { getSkillVersionCached, withSkillVersion } from './skill-version-reader.js';
@@ -306,12 +306,27 @@ export async function onClosePositionFilled(ctx, inputs, order) {
     };
     ctx.decisionsClient.postClose(ctx.userId, close);
     // Re-entry indication (issue #204) — record the exit so scan_pairs can flag
-    // same-bar re-entries on this (symbol, setup).
+    // same-bar re-entries on this (symbol, setup), and so the reentryCooldown
+    // gate can see recent losses. Live agent-closes have no engine trade record
+    // here (exchange-exact PnL arrives later on the WS fill, racing this path),
+    // so the loss sign falls back to the agent's own r_multiple_at_close — the
+    // same validator-checked field the exit gate trusts. lossSource lets the
+    // shadow soak audit that sign against the DB before enforce.
+    const rRaw = inputs.closeAssessment?.['r_multiple_at_close'];
+    const rAtClose = typeof rRaw === 'number' && Number.isFinite(rRaw) ? rRaw : undefined;
     ctx.reentryTracker?.recordExit({
         symbol: inputs.symbol,
         setupType: stateEntry.setupType ?? paperTrade?.setupType,
         side: stateEntry.side,
-        wasLoss: paperTrade ? paperTrade.netRealizedPnl < 0 : undefined,
+        wasLoss: paperTrade
+            ? paperTrade.netRealizedPnl < 0
+            : rAtClose != null
+                ? rAtClose < 0
+                : undefined,
+        lossSource: paperTrade ? 'paper_engine' : rAtClose != null ? 'assessment_r' : undefined,
+        mode: ctx.resolveMode?.(),
+        realizedR: rAtClose,
+        realizedPnl: paperTrade?.netRealizedPnl,
         closedAtMs: closeAtMs,
     });
     // Drop local state — symbol can re-enter as a new position.
@@ -388,6 +403,7 @@ export async function onAutoFlattenClose(ctx, inputs, lookup = {
         symbol: inputs.symbol,
         setupType: flattenState?.setupType,
         side: flattenState?.side ?? 'long',
+        mode: ctx.resolveMode?.(),
         closedAtMs: inputs.observedAtMs ?? Date.now(),
     });
     ctx.stateStore.remove(inputs.symbol);
@@ -421,6 +437,9 @@ export async function onStopWatcherClose(ctx, inputs) {
         setupType: stateEntry?.setupType ?? paperTrade?.setupType,
         side: stateEntry?.side ?? 'long',
         wasLoss: paperTrade ? paperTrade.netRealizedPnl < 0 : undefined,
+        lossSource: paperTrade ? 'paper_engine' : undefined,
+        mode: ctx.resolveMode?.(),
+        realizedPnl: paperTrade?.netRealizedPnl,
         closedAtMs: closeAtMs,
     });
     const dropState = () => { ctx.stateStore?.remove(inputs.symbol); };
@@ -627,7 +646,13 @@ async function handleReduceOnlyExit(ctx, fill) {
     // onClosePositionFilled) or a manual/external close — both are handled by
     // their own paths (close_position's rich reason+assessment, or the reconciler
     // backstop). Closing here would clobber the agent's close reasoning, so defer.
-    const isBracket = fill.clientOrderId ? isBracketCid(fill.clientOrderId) : false;
+    // Recognition is VENUE-DISPATCHED (bracket-id rule): Binance `bkt…`/`rc-…`
+    // cids, Hyperliquid `0xbc7…` cloids — the Binance-only check silently
+    // classed every HL bracket fill as external and deferred it forever.
+    const cidVenue = ctx.venue ?? 'binance';
+    const isBracket = fill.clientOrderId
+        ? isBracketClientId(cidVenue, fill.clientOrderId)
+        : false;
     if (!isBracket) {
         logger.info(TAG, `${fill.symbol} flat via non-bracket reduce-only fill (cid=${fill.clientOrderId ?? 'none'}) — ` +
             `deferring close to close_position / reconciler backstop (no clobber)`);
@@ -643,6 +668,12 @@ async function handleReduceOnlyExit(ctx, fill) {
                 'Auto-journaled from the WS fill — no close_position call (close-bypass path).',
             observedFrom: 'ws_reduce_only_fill',
             clientOrderId: fill.clientOrderId,
+            // Which protective leg fired ('stop' | 'target'), parsed from the cid.
+            // Kept in the assessment (not a new close reason) so the close_reason
+            // vocabulary stays stable for the miner's plan-adherence classifier.
+            leg: fill.clientOrderId
+                ? parseBracketClientId(cidVenue, fill.clientOrderId)?.role
+                : undefined,
         },
         scorecardVerdict: 'NO_GO',
         confluenceScore: 0,
@@ -668,6 +699,9 @@ async function handleReduceOnlyExit(ctx, fill) {
         setupType: stateEntry.setupType,
         side: stateEntry.side,
         wasLoss: realizedPnl < 0,
+        lossSource: 'ws_fill',
+        mode: ctx.resolveMode?.(),
+        realizedPnl,
         closedAtMs: fill.exchangeTimeMs ?? Date.now(),
     });
     ctx.stateStore.remove(fill.symbol);
@@ -733,5 +767,16 @@ export function buildEntryPlanMetadata(md) {
             j.note = rr.note;
         out.realization_rule = j;
     }
+    // Cooldown-gate measurement tag (snake_case per the canonical JSONB key
+    // rule) — present only when the gate triggered and the entry fired anyway.
+    const rc = md.reentryCooldown;
+    if (rc) {
+        out.reentry_cooldown = {
+            mode: rc.mode,
+            minutes_since_loss: rc.minutesSinceLoss,
+            cooldown_minutes: rc.cooldownMinutes,
+            would_block: rc.wouldBlock,
+        };
+    }
     return Object.keys(out).length > 0 ? out : undefined;
 }

package/ingest/position-decisions-client.d.ts

@@ -322,6 +322,12 @@ export declare class PositionDecisionsClient {
     private fireAndForget;
     private run;
     private runReturning;
+    /** Decision-path GET budget. Every read caller degrades to empty/null on
+     *  failure, so burning the write-grade budget (4 × 10s + backoff ≈ 42s
+     *  worst case) of the agent's turn to reach an optional result is pure
+     *  heartbeat latency. Background reads (reconcile sweep) override per call. */
+    private static readonly READ_MAX_ATTEMPTS;
+    private static readonly READ_DEADLINE_MS;
     private runGetReturning;
     private sleepBackoff;
 }

package/ingest/position-decisions-client.js

@@ -12,6 +12,7 @@
 //   - postEntry/Review/Close are fire-and-forget (don't block the WS hot path).
 //
 // All four routes accept the same auth: Bearer + X-User-Id headers.
+import { keepAliveFetch } from '../http/keepalive-fetch.js';
 import { logger, formatError } from '../logger.js';
 const TAG = 'position-decisions-client';
 export class PositionDecisionsClient {
@@ -25,7 +26,7 @@ export class PositionDecisionsClient {
         this.opts = {
             baseUrl: options.baseUrl.replace(/\/+$/, ''),
             ingestToken: options.ingestToken,
-            fetchImpl: options.fetchImpl ?? fetch,
+            fetchImpl: options.fetchImpl ?? keepAliveFetch,
             requestTimeoutMs: options.requestTimeoutMs ?? 10_000,
             maxAttempts: options.maxAttempts ?? 4,
             baseBackoffMs: options.baseBackoffMs ?? 250,
@@ -65,7 +66,12 @@ export class PositionDecisionsClient {
             qs.set('mode', mode);
         if (exchange)
             qs.set('exchange', exchange);
-        return this.runGetReturning(userId, `/api/internal/positions?${qs.toString()}`);
+        return this.runGetReturning(userId, `/api/internal/positions?${qs.toString()}`, {
+            // Reconcile-sweep read, NOT on the agent decision path — keep the
+            // write-grade retry budget: a null here skips a whole reconcile pass.
+            maxAttempts: this.opts.maxAttempts,
+            deadlineMs: Number.POSITIVE_INFINITY,
+        });
     }
     /** Read endpoint for the Phase 1 self-reflection feature. Awaited.
      *  Returns null on terminal/retry-exhausted failure (caller logs + degrades). */
@@ -246,12 +252,24 @@ export class PositionDecisionsClient {
         logger.error(TAG, `POST ${url} dropped after ${this.opts.maxAttempts} attempts. userId=${userId}.`);
         return null;
     }
-    async runGetReturning(userId, path) {
+    /** Decision-path GET budget. Every read caller degrades to empty/null on
+     *  failure, so burning the write-grade budget (4 × 10s + backoff ≈ 42s
+     *  worst case) of the agent's turn to reach an optional result is pure
+     *  heartbeat latency. Background reads (reconcile sweep) override per call. */
+    static READ_MAX_ATTEMPTS = 2;
+    static READ_DEADLINE_MS = 8_000;
+    async runGetReturning(userId, path, budget) {
         const url = `${this.opts.baseUrl}${path}`;
-        for (let attempt = 1; attempt <= this.opts.maxAttempts; attempt++) {
+        const maxAttempts = budget?.maxAttempts ??
+            Math.min(this.opts.maxAttempts, PositionDecisionsClient.READ_MAX_ATTEMPTS);
+        const deadlineAt = Date.now() + (budget?.deadlineMs ?? PositionDecisionsClient.READ_DEADLINE_MS);
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            const remainingMs = deadlineAt - Date.now();
+            if (remainingMs <= 0)
+                break;
             try {
                 const ac = new AbortController();
-                const tid = setTimeout(() => ac.abort(), this.opts.requestTimeoutMs);
+                const tid = setTimeout(() => ac.abort(), Math.min(this.opts.requestTimeoutMs, remainingMs));
                 let res;
                 try {
                     res = await this.opts.fetchImpl(url, {
@@ -285,16 +303,16 @@ export class PositionDecisionsClient {
                     logger.warn(TAG, `GET ${url} → ${res.status} (terminal, dropped). userId=${userId} body=${errBody.slice(0, 200)}`);
                     return null;
                 }
-                logger.warn(TAG, `GET ${url} → ${res.status} (attempt ${attempt}/${this.opts.maxAttempts}).`);
+                logger.warn(TAG, `GET ${url} → ${res.status} (attempt ${attempt}/${maxAttempts}).`);
             }
             catch (err) {
-                logger.warn(TAG, `GET ${url} threw (attempt ${attempt}/${this.opts.maxAttempts}): ${formatError(err)}`);
+                logger.warn(TAG, `GET ${url} threw (attempt ${attempt}/${maxAttempts}): ${formatError(err)}`);
             }
-            if (attempt < this.opts.maxAttempts) {
+            if (attempt < maxAttempts && Date.now() < deadlineAt) {
                 await this.sleepBackoff(attempt);
             }
         }
-        logger.error(TAG, `GET ${url} failed after ${this.opts.maxAttempts} attempts. userId=${userId}.`);
+        logger.error(TAG, `GET ${url} failed after ${maxAttempts} attempt(s)/deadline. userId=${userId}.`);
         return null;
     }
     async sleepBackoff(attempt) {