@reefclaw/openclaw-plugin 0.1.5 → 0.1.6

package/tools/get-wave9-status.js

@@ -0,0 +1,796 @@
+import { createHash } from 'node:crypto';
+import { applyWave9AdmissionBatch, } from '../portfolio/wave9-admission.js';
+import { DAY_MS, evaluateWave9Daily, WAVE9_LONG_STRATEGY, WAVE9_SHORT_STRATEGY, WAVE9_SYMBOL_PRIORITY, } from '../portfolio/wave9-policy.js';
+import { FOUR_HOURS_MS, createWave9UsdmEvidenceProvider, } from '../wave9/usdm-evidence-provider.js';
+import { isWave9ManagedPosition } from '../wave9/paper-admission-guard.js';
+import { fetchIntelApi } from './intel-api.js';
+export const WAVE9_BUNDLE_NAME = 'wave9_28d_momentum_reversal';
+export const WAVE9_EXECUTION_KERNEL = 'wave9_shared_v1';
+export const WAVE9_PAPER_ENTRY_WINDOW_MS = 10 * 60_000;
+export class IntelWave9ActivationClient {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async getActivation() {
+        const result = await fetchIntelApi('/api/wave9/activation', this.deps);
+        if ('error' in result) {
+            return {
+                available: false,
+                name: WAVE9_BUNDLE_NAME,
+                executionModel: WAVE9_EXECUTION_KERNEL,
+                active: false,
+                error: String(result.error),
+            };
+        }
+        const bundle = result.bundle;
+        if (!bundle || typeof bundle !== 'object' || Array.isArray(bundle)) {
+            return invalidActivation('response did not contain a bundle object');
+        }
+        const row = bundle;
+        if (row.name !== WAVE9_BUNDLE_NAME
+            || row.executionModel !== WAVE9_EXECUTION_KERNEL
+            || typeof row.active !== 'boolean'
+            || (row.source !== undefined
+                && row.source !== 'tenant_override'
+                && row.source !== 'global_default')) {
+            return invalidActivation('response bundle failed strict validation');
+        }
+        return {
+            available: true,
+            name: WAVE9_BUNDLE_NAME,
+            executionModel: WAVE9_EXECUTION_KERNEL,
+            active: row.active,
+            ...(row.source ? { source: row.source } : {}),
+        };
+    }
+}
+function invalidActivation(reason) {
+    return {
+        available: false,
+        name: WAVE9_BUNDLE_NAME,
+        executionModel: WAVE9_EXECUTION_KERNEL,
+        active: false,
+        error: `Invalid Wave 9 activation response: ${reason}`,
+    };
+}
+function isExecutableMode(mode) {
+    return mode === 'PAPER' || mode === 'LIVE';
+}
+function canonicalSymbol(symbol) {
+    return symbol.toUpperCase().replace(/[^A-Z0-9]/g, '').replace(/USDTUSDT$/, 'USDT');
+}
+function executionSymbol(symbol) {
+    const canonical = canonicalSymbol(symbol);
+    if (!canonical.endsWith('USDT'))
+        throw new Error(`unsupported Wave 9 execution symbol ${symbol}`);
+    return `${canonical.slice(0, -4)}/USDT:USDT`;
+}
+function isWave9Position(position) {
+    return isWave9ManagedPosition(position);
+}
+export function wave9MissionId(candidateId) {
+    return `wave9_${createHash('sha256').update(candidateId).digest('hex').slice(0, 32)}`;
+}
+function nearlyEqual(left, right) {
+    return Math.abs(left - right) <= 1e-9 * Math.max(1, Math.abs(left), Math.abs(right));
+}
+function requireBatch(batch, eventMs) {
+    if (batch.venue !== 'binance_usdm'
+        || batch.marketType !== 'future'
+        || batch.eventTime.getTime() !== eventMs
+        || batch.symbols.length !== WAVE9_SYMBOL_PRIORITY.length) {
+        throw new Error('Wave 9 atomic evidence identity mismatch');
+    }
+    for (const [index, row] of batch.symbols.entries()) {
+        if (row.symbol !== WAVE9_SYMBOL_PRIORITY[index]) {
+            throw new Error('Wave 9 atomic evidence universe/order mismatch');
+        }
+        const opening = row.fourHourBars.find((bar) => bar.time.getTime() === eventMs);
+        const completed = row.fourHourBars.find((bar) => bar.time.getTime() === eventMs - FOUR_HOURS_MS);
+        if (!opening || !completed) {
+            throw new Error(`Wave 9 4h boundary evidence missing for ${row.symbol}`);
+        }
+    }
+}
+function controlState(activation, snapshot, wave9Positions) {
+    if (activation.available && activation.active) {
+        return { state: 'active', reason: 'tenant_bundle_active' };
+    }
+    if (wave9Positions.length > 0) {
+        return { state: 'exit_only', reason: 'bundle_inactive_with_open_wave9_position' };
+    }
+    if (!activation.available || !snapshot.positionsAvailable) {
+        return {
+            state: 'exit_only',
+            reason: !activation.available
+                ? 'activation_unavailable_fail_closed'
+                : 'positions_unavailable_fail_closed',
+        };
+    }
+    return { state: 'inactive', reason: 'tenant_bundle_inactive_and_flat' };
+}
+function canonicalAdmissionBook(snapshot) {
+    const reasons = [];
+    const limitations = [
+        'failed_attempt_event_latch_is_process_local_and_resets_on_restart',
+    ];
+    if (snapshot.tradingMode === 'PAPER') {
+        limitations.push('market_mark_fingerprint_drift_requires_immediate_status_recall', 'paper_funding_not_booked', 'process_local_unlocked_simulator', 'cross_process_lease_absent_duplicate_concurrent_admission_not_ruled_out');
+    }
+    else {
+        limitations.push('live_candidate_identity_uses_local_durable_execution_ledger', 'non_wave9_positions_are_enforced_by_the_generic_live_pretrade_gate', 'live_funding_is_not_attributed_per_wave9_position');
+    }
+    if (!isExecutableMode(snapshot.tradingMode)) {
+        reasons.push('Wave 9 execution supports PAPER and LIVE only');
+    }
+    if (snapshot.tradingMode === 'LIVE'
+        && snapshot.nativeStopProtectionAvailable !== true) {
+        reasons.push('native stop protection is unavailable for LIVE Wave 9 execution');
+    }
+    if (!snapshot.positionsAvailable || !snapshot.positions) {
+        reasons.push('locally complete account positions are unavailable');
+    }
+    if (!snapshot.openOrdersAvailable || snapshot.openOrderCount === undefined) {
+        reasons.push('locally complete open-order state is unavailable');
+    }
+    else if (!Number.isInteger(snapshot.openOrderCount) || snapshot.openOrderCount < 0) {
+        reasons.push('open-order count is invalid');
+    }
+    else if (snapshot.openOrderCount > 0) {
+        reasons.push('pending exposure-increasing orders make admission geometry ambiguous');
+    }
+    if (!snapshot.cashEquityAvailable
+        || snapshot.cashEquityUsd === undefined
+        || !Number.isFinite(snapshot.cashEquityUsd)
+        || snapshot.cashEquityUsd <= 0) {
+        reasons.push('locally complete positive wallet cash is unavailable');
+    }
+    if (!snapshot.accountFingerprint
+        || !/^[a-f0-9]{64}$/.test(snapshot.accountFingerprint)) {
+        reasons.push('valid account fingerprint is unavailable');
+    }
+    const observed = snapshot.positions ?? [];
+    const nonWave9 = observed.filter((position) => !isWave9Position(position));
+    if (snapshot.tradingMode === 'PAPER' && nonWave9.length > 0) {
+        reasons.push('non-Wave 9 positions make isolated-book projection ambiguous');
+    }
+    const positions = [];
+    for (const position of observed.filter(isWave9Position)) {
+        const symbol = canonicalSymbol(position.symbol);
+        const direction = position.side === 'long' ? 'LONG' : 'SHORT';
+        const expectedStrategy = direction === 'LONG' ? WAVE9_LONG_STRATEGY : WAVE9_SHORT_STRATEGY;
+        if (snapshot.tradingMode === 'LIVE' && position.nativeStop?.verified !== true) {
+            reasons.push(`verified exchange-native stop unavailable for ${position.missionId ?? symbol}`
+                + `:${position.nativeStop?.reason ?? 'native_stop_missing'}`);
+            continue;
+        }
+        if (!position.candidateId
+            || !position.missionId
+            || position.missionId !== wave9MissionId(position.candidateId)
+            || position.strategy !== expectedStrategy
+            || !WAVE9_SYMBOL_PRIORITY.includes(symbol)
+            || position.stopPrice === undefined
+            || !Number.isFinite(position.stopPrice)
+            || (position.accruedFundingUsd !== undefined
+                && !Number.isFinite(position.accruedFundingUsd))
+            || !Number.isFinite(position.quantity)
+            || position.quantity <= 0
+            || !Number.isFinite(position.entryPrice)
+            || position.entryPrice <= 0
+            || !Number.isFinite(position.markPrice)
+            || position.markPrice <= 0) {
+            reasons.push(`incomplete durable Wave 9 geometry for ${position.missionId ?? symbol}`);
+            continue;
+        }
+        positions.push({
+            candidateId: position.candidateId,
+            symbol,
+            strategy: position.strategy,
+            direction,
+            entryPrice: position.entryPrice,
+            quantity: position.quantity,
+            markPrice: position.markPrice,
+            initialStop: position.stopPrice,
+            dollarRiskUsd: Math.abs(position.entryPrice - position.stopPrice) * position.quantity,
+            // PAPER does not book per-position funding and the LIVE execution
+            // ledger does not yet attribute it, so both capture paths expose zero.
+            accruedFundingUsd: position.accruedFundingUsd ?? 0,
+        });
+    }
+    if (positions.length !== observed.filter(isWave9Position).length) {
+        reasons.push('not every observed Wave 9 position has complete local admission geometry');
+    }
+    return {
+        available: reasons.length === 0,
+        ...(snapshot.cashEquityUsd !== undefined ? { cashEquityUsd: snapshot.cashEquityUsd } : {}),
+        positions,
+        reasons: [...new Set(reasons)],
+        limitations: [...new Set([...(snapshot.reasons ?? []), ...limitations])],
+    };
+}
+function candidateFor(symbol, eventTime, openingPrice, entry) {
+    return {
+        id: `${eventTime}|${symbol}|${entry.strategy}|${entry.direction}`,
+        eventTime,
+        symbol,
+        strategy: entry.strategy,
+        direction: entry.direction,
+        referencePrice: openingPrice,
+        stopPrice: entry.stopPrice,
+    };
+}
+function decisionSummary(decision) {
+    return {
+        candidateId: decision.id,
+        missionId: wave9MissionId(decision.id),
+        accepted: decision.accepted,
+        reason: decision.reason,
+        direction: decision.direction,
+        referenceOpen: decision.referencePrice,
+        modeledEntryPrice: decision.entryPrice ?? null,
+        quantity: decision.quantity ?? null,
+        stopPrice: decision.stopPrice,
+        targets: [],
+        targetPolicy: 'none_completed_daily_signal_reversal',
+        projectedOpenPositions: decision.projectedOpenPositions ?? null,
+        projectedGrossExposureUsd: decision.projectedGrossExposureUsd ?? null,
+        projectedOpenRiskUsd: decision.projectedOpenRiskUsd ?? null,
+        projectedLiquidationEquityUsd: decision.projectedLiquidationEquityUsd ?? null,
+    };
+}
+function batchId(eventTime, decisions, accountFingerprint, tradingMode) {
+    const identity = decisions.map((decision) => decision.id).join('\n');
+    return `wave9_batch_${createHash('sha256')
+        .update(`${eventTime}\n${tradingMode}\n${accountFingerprint}\n${identity}`)
+        .digest('hex').slice(0, 24)}`;
+}
+function authorizationAbsenceMeaning(state, modeSupported, venueSupported) {
+    if (!venueSupported)
+        return 'strategy_unavailable_on_current_venue';
+    if (!modeSupported)
+        return 'strategy_unavailable_in_current_mode';
+    if (state === 'inactive')
+        return 'strategy_disabled_by_operator_toggle';
+    if (state === 'exit_only')
+        return 'no_new_entries_exit_management_only';
+    return 'wait_strategy_remains_enabled';
+}
+function baseStatus(activation, snapshot, state, observedAt, executionVenue, clockValid) {
+    const modeSupported = isExecutableMode(snapshot.tradingMode);
+    const venueSupported = executionVenue === 'binance';
+    const runtimeReadinessFailures = [];
+    if (!clockValid)
+        runtimeReadinessFailures.push('status_clock_invalid');
+    if (!venueSupported)
+        runtimeReadinessFailures.push('unsupported_execution_venue');
+    if (!modeSupported)
+        runtimeReadinessFailures.push('unsupported_trading_mode');
+    if (state.state === 'inactive') {
+        runtimeReadinessFailures.push('strategy_disabled_by_operator_toggle');
+    }
+    else if (state.state === 'exit_only') {
+        runtimeReadinessFailures.push(`control_state_exit_only:${state.reason}`);
+    }
+    if (!snapshot.positionsAvailable)
+        runtimeReadinessFailures.push('account_positions_unavailable');
+    if (!snapshot.openOrdersAvailable)
+        runtimeReadinessFailures.push('account_open_orders_unavailable');
+    if (!snapshot.cashEquityAvailable)
+        runtimeReadinessFailures.push('account_cash_equity_unavailable');
+    if (snapshot.tradingMode === 'LIVE') {
+        if (snapshot.adapterReadiness !== 'READY') {
+            runtimeReadinessFailures.push(`live_adapter_not_ready:${snapshot.adapterReadiness ?? 'unknown'}`);
+        }
+        if (snapshot.nativeStopProtectionAvailable !== true) {
+            runtimeReadinessFailures.push('live_native_stop_protection_unavailable');
+        }
+    }
+    const runtimeReadyForNewEntryAuthorization = runtimeReadinessFailures.length === 0;
+    const runtimeReadinessReasons = runtimeReadyForNewEntryAuthorization
+        ? [snapshot.tradingMode === 'LIVE'
+                ? 'live_adapter_account_and_native_stops_ready'
+                : 'paper_account_snapshot_ready']
+        : [...new Set(runtimeReadinessFailures)];
+    const strategyEnabled = activation.available && activation.active;
+    const liveCapabilityEnabled = strategyEnabled
+        && state.state === 'active'
+        && venueSupported
+        && snapshot.tradingMode === 'LIVE';
+    const effectiveStatus = !venueSupported
+        ? 'unsupported_venue'
+        : !modeSupported
+            ? 'unsupported_mode'
+            : state.state === 'inactive'
+                ? 'disabled_by_operator_toggle'
+                : state.state === 'exit_only'
+                    ? 'exit_only'
+                    : snapshot.tradingMode === 'LIVE'
+                        ? 'live_enabled'
+                        : 'paper_enabled';
+    const missingCurrentAuthorizationMeans = authorizationAbsenceMeaning(state.state, modeSupported, venueSupported);
+    return {
+        kind: 'wave9_agent_status',
+        statusContractVersion: 2,
+        bundle: activation,
+        controlState: state.state,
+        controlStateReason: state.reason,
+        executionKernel: WAVE9_EXECUTION_KERNEL,
+        tradeability: {
+            effectiveStatus,
+            strategyEnabled,
+            operatorToggleActive: strategyEnabled,
+            venue: executionVenue,
+            venueSupported,
+            currentMode: snapshot.tradingMode,
+            supportedModes: ['PAPER', 'LIVE'],
+            currentModeSupported: modeSupported,
+            adapterReadiness: snapshot.adapterReadiness ?? null,
+            wave9PositionCount: snapshot.positionsAvailable
+                ? (snapshot.positions ?? []).filter(isWave9Position).length
+                : null,
+            liveCapabilityEnabled,
+            usesRealFunds: snapshot.tradingMode === 'LIVE' || snapshot.tradingMode === 'MICRO_LIVE',
+            runtimeReadyForNewEntryAuthorization,
+            runtimeReadinessReasons,
+            authorizationModel: 'short_lived_exact_token',
+            missingCurrentAuthorizationMeans,
+        },
+        currentActionAuthorization: {
+            entry: 'none',
+            exit: 'none',
+            entryCount: 0,
+            exitCount: 0,
+            entryReason: 'not_evaluated',
+            exitReason: 'not_evaluated',
+            noneMeaning: missingCurrentAuthorizationMeans,
+        },
+        statusCall: {
+            mutatesOrders: false,
+            returnedAuthorizationsMayAuthorizeOrders: true,
+        },
+        observedAt,
+        accountProvenance: {
+            source: snapshot.source,
+            provenance: snapshot.provenance,
+            authoritative: snapshot.authoritative,
+            accountFingerprint: snapshot.accountFingerprint ?? null,
+        },
+    };
+}
+function currentActionAuthorization(entryCount, exitCount, entryReason, exitReason, noneMeaning) {
+    return {
+        entry: entryCount > 0 ? 'authorized' : 'none',
+        exit: exitCount > 0 ? 'authorized' : 'none',
+        entryCount,
+        exitCount,
+        entryReason,
+        exitReason,
+        noneMeaning,
+    };
+}
+function requiredOperatorReport(base, action) {
+    const tradeability = base.tradeability;
+    const currentMode = String(tradeability.currentMode ?? 'UNKNOWN');
+    const effectiveStatus = String(tradeability.effectiveStatus ?? 'unknown');
+    const liveCapabilityEnabled = tradeability.liveCapabilityEnabled === true;
+    const usesRealFunds = tradeability.usesRealFunds === true;
+    const runtimeReady = tradeability.runtimeReadyForNewEntryAuthorization === true;
+    const runtimeReadinessReasons = Array.isArray(tradeability.runtimeReadinessReasons)
+        ? tradeability.runtimeReadinessReasons.map(String)
+        : ['runtime_readiness_reason_unavailable'];
+    const entryCount = Number(action.entryCount ?? 0);
+    const exitCount = Number(action.exitCount ?? 0);
+    const entryReason = String(action.entryReason ?? 'unknown');
+    const exitReason = String(action.exitReason ?? 'unknown');
+    const liveCapabilityLine = currentMode === 'LIVE' && liveCapabilityEnabled
+        ? 'Wave 9 is enabled for LIVE trading.'
+        : `Wave 9 LIVE capability: ${liveCapabilityEnabled ? 'enabled' : 'not enabled'} (effective status: ${effectiveStatus}; current mode: ${currentMode}).`;
+    return {
+        contractVersion: 1,
+        instruction: 'Reproduce every line below in the operator reply. Do not omit, merge, or paraphrase away the labels, counts, or reasons.',
+        lines: [
+            liveCapabilityLine,
+            `Current mode: ${currentMode}; real funds: ${usesRealFunds ? 'yes' : 'no'}.`,
+            `Runtime readiness for new entry authorization: ${runtimeReady ? 'READY' : 'NOT READY'} (${runtimeReady}; reasons: ${runtimeReadinessReasons.join(', ')}).`,
+            `Current entry authorizations: ${entryCount} (reason: ${entryReason}).`,
+            `Current exit authorizations: ${exitCount} (reason: ${exitReason}).`,
+        ],
+        readOnlyBoundary: 'Reporting status alone does not authorize placing or closing an order or toggling a strategy.',
+    };
+}
+function statusWithCurrentAction(base, action) {
+    return {
+        ...base,
+        currentActionAuthorization: action,
+        requiredOperatorReport: requiredOperatorReport(base, action),
+    };
+}
+export async function getWave9StatusTool(deps) {
+    const now = (deps.now ?? (() => new Date()))();
+    const nowMs = now.getTime();
+    const clockValid = Number.isFinite(nowMs);
+    const activation = await deps.activationClient.getActivation();
+    const preflightSnapshot = await deps.operationLock.withAccountLock('wave9-status-preflight', () => deps.getAccountSnapshot());
+    const observedPositions = preflightSnapshot.positionsAvailable
+        ? (preflightSnapshot.positions ?? [])
+        : [];
+    const wave9Positions = observedPositions.filter(isWave9Position);
+    const state = controlState(activation, preflightSnapshot, wave9Positions);
+    const base = baseStatus(activation, preflightSnapshot, state, clockValid ? now.toISOString() : null, deps.executionVenue, clockValid);
+    if (!clockValid) {
+        return {
+            ...statusWithCurrentAction(base, currentActionAuthorization(0, 0, 'invalid_status_clock', 'invalid_status_clock', authorizationAbsenceMeaning(state.state, isExecutableMode(preflightSnapshot.tradingMode), deps.executionVenue === 'binance'))),
+            error: 'Wave 9 status clock is invalid',
+            evidenceAvailable: false,
+            evaluationSkipped: 'invalid_status_clock',
+            decisions: [],
+            authorizations: { entries: [], exits: [] },
+        };
+    }
+    if (deps.executionVenue !== 'binance') {
+        return {
+            ...statusWithCurrentAction(base, currentActionAuthorization(0, 0, 'unsupported_execution_venue', 'unsupported_execution_venue', 'strategy_unavailable_on_current_venue')),
+            evidenceAvailable: false,
+            evaluationSkipped: 'unsupported_execution_venue',
+            venue: deps.executionVenue,
+            reason: 'Wave 9 is pinned to Binance USD-M futures and is unavailable on this execution venue.',
+            decisions: [],
+            authorizations: { entries: [], exits: [] },
+        };
+    }
+    if (!isExecutableMode(preflightSnapshot.tradingMode)) {
+        return {
+            ...statusWithCurrentAction(base, currentActionAuthorization(0, 0, 'unsupported_trading_mode', 'unsupported_trading_mode', 'strategy_unavailable_in_current_mode')),
+            evidenceAvailable: false,
+            evaluationSkipped: 'unsupported_trading_mode',
+            reason: 'Wave 9 authorizes exact PAPER or LIVE execution only; SHADOW and MICRO_LIVE are unsupported.',
+            accountAdmission: canonicalAdmissionBook(preflightSnapshot),
+            decisions: [],
+            authorizations: { entries: [], exits: [] },
+        };
+    }
+    // Inactive + authoritatively flat is a true no-market-construction path.
+    if (state.state === 'inactive') {
+        return {
+            ...statusWithCurrentAction(base, currentActionAuthorization(0, 0, 'disabled_by_operator_toggle', 'no_managed_position', 'strategy_disabled_by_operator_toggle')),
+            evidenceAvailable: false,
+            evaluationSkipped: 'bundle_inactive_and_flat',
+            decisions: [],
+            authorizations: { entries: [], exits: [] },
+        };
+    }
+    const eventMs = Math.floor(nowMs / DAY_MS) * DAY_MS;
+    const eventTime = new Date(eventMs).toISOString();
+    const entryDeadlineMs = eventMs + WAVE9_PAPER_ENTRY_WINDOW_MS;
+    const entryWindowStatus = nowMs < entryDeadlineMs ? 'open' : 'missed_open';
+    let batch;
+    try {
+        const provider = (deps.createEvidenceProvider ?? createWave9UsdmEvidenceProvider)();
+        batch = await provider.fetchAtomicBatch(new Date(eventMs));
+        requireBatch(batch, eventMs);
+    }
+    catch (error) {
+        return {
+            ...statusWithCurrentAction(base, currentActionAuthorization(0, 0, 'evidence_unavailable', 'evidence_unavailable', authorizationAbsenceMeaning(state.state, true, true))),
+            eventTime,
+            evidenceAvailable: false,
+            evidenceError: error instanceof Error ? error.message : String(error),
+            entryWindow: {
+                status: entryWindowStatus,
+                opensAt: eventTime,
+                closesAt: new Date(entryDeadlineMs).toISOString(),
+                observedDelayMs: nowMs - eventMs,
+            },
+            decisions: [],
+            authorizations: { entries: [], exits: [] },
+        };
+    }
+    const evaluate = deps.evaluateDaily ?? evaluateWave9Daily;
+    const dailyBySymbol = new Map();
+    const candidates = [];
+    try {
+        for (const row of batch.symbols) {
+            const daily = evaluate(row.dailyBars, new Date(eventMs));
+            const completed = row.fourHourBars.find((bar) => bar.time.getTime() === eventMs - FOUR_HOURS_MS);
+            if (!nearlyEqual(daily.referencePrice, completed.close)) {
+                throw new Error(`${row.symbol} completed-daily close does not match final completed 4h close`);
+            }
+            const opening = row.fourHourBars.find((bar) => bar.time.getTime() === eventMs).open;
+            dailyBySymbol.set(row.symbol, daily);
+            for (const entry of daily.entries) {
+                candidates.push(candidateFor(row.symbol, eventTime, opening, entry));
+            }
+        }
+    }
+    catch (error) {
+        return {
+            ...statusWithCurrentAction(base, currentActionAuthorization(0, 0, 'evaluation_failed', 'evaluation_failed', authorizationAbsenceMeaning(state.state, true, true))),
+            eventTime,
+            evidenceAvailable: false,
+            evidenceError: error instanceof Error ? error.message : String(error),
+            decisions: [],
+            authorizations: { entries: [], exits: [] },
+        };
+    }
+    // Market I/O stays outside the trading lock. Re-capture the account
+    // and issue all short-lived authorizations inside one serialized section so
+    // a watcher/tool mutation cannot race snapshot-to-token binding.
+    return deps.operationLock.withAccountLock('wave9-status-snapshot-and-authorize', async () => {
+        const snapshot = await deps.getAccountSnapshot();
+        const lockedObservedPositions = snapshot.positionsAvailable ? (snapshot.positions ?? []) : [];
+        const lockedWave9Positions = lockedObservedPositions.filter(isWave9Position);
+        const lockedState = controlState(activation, snapshot, lockedWave9Positions);
+        const lockedBase = baseStatus(activation, snapshot, lockedState, now.toISOString(), deps.executionVenue, true);
+        const book = canonicalAdmissionBook(snapshot);
+        const alreadyExecutedThisEvent = new Set((snapshot.executedCandidateIds ?? []).filter((candidateId) => typeof candidateId === 'string' && candidateId.startsWith(`${eventTime}|`)));
+        const occupiedNonWave9Symbols = new Set(lockedObservedPositions
+            .filter((position) => !isWave9Position(position))
+            .map((position) => canonicalSymbol(position.symbol)));
+        const admissionCandidates = candidates.filter((candidate) => !alreadyExecutedThisEvent.has(candidate.id)
+            && !occupiedNonWave9Symbols.has(candidate.symbol));
+        // Reversal release is chronologically before same-event admission. When a
+        // held position must exit, issue only the exit capability and require the
+        // agent to re-call status after the close; never compute/authorize entries
+        // against a position that is logically released but still actually held.
+        const reversalDuePositions = lockedWave9Positions.filter((position) => {
+            const daily = dailyBySymbol.get(canonicalSymbol(position.symbol));
+            return daily
+                ? (position.side === 'long' ? daily.exitLong : daily.exitShort)
+                : false;
+        });
+        const exitInputs = [];
+        if (isExecutableMode(snapshot.tradingMode)
+            && deps.authorizationIssuer) {
+            for (const position of lockedWave9Positions) {
+                const symbol = canonicalSymbol(position.symbol);
+                const daily = dailyBySymbol.get(symbol);
+                if (!daily
+                    || !position.missionId
+                    || !position.candidateId
+                    || !position.positionFingerprint
+                    || !/^[a-f0-9]{64}$/.test(position.positionFingerprint))
+                    continue;
+                const reversalDue = position.side === 'long' ? daily.exitLong : daily.exitShort;
+                if (!reversalDue)
+                    continue;
+                exitInputs.push({
+                    candidateId: position.candidateId,
+                    missionId: position.missionId,
+                    symbol,
+                    positionSide: position.side,
+                    reason: 'signal_reversal',
+                    notBeforeMs: eventMs,
+                    deadlineMs: eventMs + DAY_MS,
+                    positionFingerprint: position.positionFingerprint,
+                    tradingMode: snapshot.tradingMode,
+                });
+            }
+        }
+        let issuedExits = [];
+        if (exitInputs.length > 0) {
+            try {
+                issuedExits = [...deps.authorizationIssuer.issueExitBatch(exitInputs)];
+            }
+            catch {
+                // A malformed or stale recognized position must suppress admission, not
+                // crash the heartbeat/status path or expose an unusable authorization.
+                book.reasons.push('Wave 9 reversal authorization issuance failed closed');
+            }
+        }
+        const exitAuthorizationByMission = new Map(issuedExits.map((authorization) => [authorization.missionId, authorization]));
+        const pendingReversalRelease = reversalDuePositions.length > 0;
+        let admissionDecisions = [];
+        if (pendingReversalRelease) {
+            book.reasons.push('execute authorized signal-reversal exits, then re-call status before admission');
+            if (exitInputs.length !== reversalDuePositions.length
+                || issuedExits.length !== exitInputs.length) {
+                book.reasons.push('reversal_authorization_unavailable_for_one_or_more_due_positions');
+            }
+        }
+        else if (book.available && lockedState.state === 'active') {
+            try {
+                admissionDecisions = applyWave9AdmissionBatch({
+                    cashEquityUsd: book.cashEquityUsd,
+                    positions: book.positions,
+                }, admissionCandidates).decisions;
+            }
+            catch (error) {
+                book.available = false;
+                book.reasons.push(`shared admission kernel rejected account snapshot: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        else if (lockedState.state !== 'active') {
+            book.reasons.push('new admissions disabled while bundle is inactive or exit-only');
+        }
+        const admissionById = new Map(admissionDecisions.map((decision) => [decision.id, decision]));
+        const entryInputs = [];
+        if (lockedState.state === 'active'
+            && isExecutableMode(snapshot.tradingMode)
+            && entryWindowStatus === 'open'
+            && book.available
+            && !pendingReversalRelease
+            && snapshot.accountFingerprint
+            && deps.authorizationIssuer) {
+            // Authorize exactly one mutation. Its real fill/fee changes both the
+            // fingerprint and the next candidate's sizing/caps, so later accepted
+            // modeled decisions require a fresh status call against the actual book.
+            const authorizationTradingMode = snapshot.tradingMode;
+            const accepted = admissionDecisions.filter((decision) => decision.accepted).slice(0, 1);
+            const id = batchId(eventTime, admissionDecisions, snapshot.accountFingerprint, authorizationTradingMode);
+            accepted.forEach((decision, sequence) => {
+                entryInputs.push({
+                    batchId: id,
+                    candidateId: decision.id,
+                    missionId: wave9MissionId(decision.id),
+                    symbol: decision.symbol,
+                    side: decision.direction === 'LONG' ? 'BUY' : 'SELL',
+                    quantity: String(decision.quantity),
+                    stopPrice: String(decision.stopPrice),
+                    sequence,
+                    notBeforeMs: eventMs,
+                    deadlineMs: entryDeadlineMs,
+                    accountFingerprint: snapshot.accountFingerprint,
+                    tradingMode: authorizationTradingMode,
+                });
+            });
+        }
+        const issuedEntries = entryInputs.length > 0
+            ? [...deps.authorizationIssuer.issueBatch(entryInputs)]
+            : [];
+        const entryAuthorizationByCandidate = new Map(issuedEntries.map((authorization) => [authorization.candidateId, authorization]));
+        const decisions = WAVE9_SYMBOL_PRIORITY.map((symbol) => {
+            const daily = dailyBySymbol.get(symbol);
+            const position = lockedWave9Positions.find((candidate) => canonicalSymbol(candidate.symbol) === symbol);
+            const rowCandidates = candidates.filter((candidate) => candidate.symbol === symbol);
+            const entries = rowCandidates.map((candidate) => {
+                const admission = admissionById.get(candidate.id);
+                const firstAuthorizedCandidateId = issuedEntries[0]?.candidateId;
+                const alreadyExecuted = alreadyExecutedThisEvent.has(candidate.id);
+                const occupiedByNonWave9Position = occupiedNonWave9Symbols.has(candidate.symbol);
+                const authorization = entryAuthorizationByCandidate.get(candidate.id);
+                return {
+                    candidateId: candidate.id,
+                    missionId: wave9MissionId(candidate.id),
+                    executionSymbol: executionSymbol(candidate.symbol),
+                    strategy: candidate.strategy,
+                    direction: candidate.direction,
+                    referenceOpen: candidate.referencePrice,
+                    stopPrice: candidate.stopPrice,
+                    targets: [],
+                    targetPolicy: 'none_completed_daily_signal_reversal',
+                    capDecision: occupiedByNonWave9Position
+                        ? {
+                            status: 'symbol_occupied_by_non_wave9_position',
+                            reasons: ['the symbol already has a non-Wave 9 live position'],
+                        }
+                        : admission
+                            ? {
+                                ...decisionSummary(admission),
+                                authorizationStage: !admission.accepted
+                                    ? 'rejected'
+                                    : admission.id === firstAuthorizedCandidateId
+                                        ? 'authorized_now'
+                                        : entryWindowStatus === 'missed_open'
+                                            ? 'missed_open_no_authorization'
+                                            : issuedEntries.length > 0
+                                                ? 'modeled_only_recall_after_prior_fill'
+                                                : 'authorization_unavailable',
+                            }
+                            : {
+                                status: alreadyExecuted
+                                    ? 'already_executed_this_event'
+                                    : pendingReversalRelease
+                                        ? 'pending_reversal_release'
+                                        : book.available ? 'not_evaluated' : 'unavailable',
+                                reasons: alreadyExecuted
+                                    ? ['already_executed_this_event', 'already_executed_durable_history']
+                                    : book.reasons,
+                            },
+                    authorization: authorization
+                        ? { ...authorization, executionSymbol: executionSymbol(candidate.symbol) }
+                        : null,
+                };
+            });
+            const reversalDue = position
+                ? (position.side === 'long' ? daily.exitLong : daily.exitShort)
+                : false;
+            return {
+                symbol,
+                currentReturn: daily.currentReturn,
+                previousReturn: daily.previousReturn,
+                atr14: daily.atr14,
+                completedDailyReferenceClose: daily.referencePrice,
+                entryTransition: entries.length > 0,
+                capDecision: entries.length > 0
+                    ? 'see_entries'
+                    : { status: 'not_candidate', reason: 'no_completed_daily_zero_cross' },
+                entries,
+                reversal: {
+                    exitLong: daily.exitLong,
+                    exitShort: daily.exitShort,
+                    observedPositionMissionId: position?.missionId ?? null,
+                    observedPositionSide: position?.side ?? null,
+                    due: reversalDue,
+                    timing: reversalDue && entryWindowStatus === 'missed_open'
+                        ? 'missed_open_late_exit'
+                        : reversalDue ? 'at_open_window' : 'not_due',
+                    executionSymbol: position ? executionSymbol(symbol) : null,
+                    authorization: position?.missionId && exitAuthorizationByMission.has(position.missionId)
+                        ? {
+                            ...exitAuthorizationByMission.get(position.missionId),
+                            executionSymbol: executionSymbol(symbol),
+                        }
+                        : null,
+                },
+            };
+        });
+        const allCandidatesAlreadyExecuted = candidates.length > 0
+            && candidates.every((candidate) => alreadyExecutedThisEvent.has(candidate.id));
+        const allCandidateSymbolsOccupied = candidates.length > 0
+            && candidates.every((candidate) => occupiedNonWave9Symbols.has(candidate.symbol));
+        const entryAuthorizationReason = issuedEntries.length > 0
+            ? 'authorized'
+            : lockedState.state !== 'active'
+                ? 'strategy_not_active_for_entries'
+                : pendingReversalRelease
+                    ? 'execute_reversal_then_recall_status'
+                    : entryWindowStatus === 'missed_open'
+                        ? 'entry_window_closed'
+                        : !book.available
+                            ? 'account_admission_unavailable'
+                            : candidates.length === 0
+                                ? 'no_entry_signal'
+                                : admissionCandidates.length === 0
+                                    ? allCandidatesAlreadyExecuted
+                                        ? 'all_entry_signals_already_executed'
+                                        : allCandidateSymbolsOccupied
+                                            ? 'all_entry_signal_symbols_occupied_by_non_wave9_positions'
+                                            : 'entry_signals_not_eligible_for_admission'
+                                    : admissionDecisions.some((decision) => decision.accepted)
+                                        ? 'authorization_unavailable'
+                                        : 'no_candidate_passed_admission';
+        const exitAuthorizationReason = issuedExits.length > 0
+            ? 'authorized'
+            : lockedWave9Positions.length === 0
+                ? 'no_managed_position'
+                : reversalDuePositions.length === 0
+                    ? 'no_reversal_signal'
+                    : 'reversal_authorization_unavailable';
+        return {
+            ...statusWithCurrentAction(lockedBase, currentActionAuthorization(issuedEntries.length, issuedExits.length, entryAuthorizationReason, exitAuthorizationReason, authorizationAbsenceMeaning(lockedState.state, isExecutableMode(snapshot.tradingMode), deps.executionVenue === 'binance'))),
+            eventTime,
+            evidenceAvailable: true,
+            evidence: {
+                venue: batch.venue,
+                marketType: batch.marketType,
+                atomicUniverse: true,
+                symbolOrder: [...WAVE9_SYMBOL_PRIORITY],
+            },
+            entryWindow: {
+                status: entryWindowStatus,
+                opensAt: eventTime,
+                closesAt: new Date(entryDeadlineMs).toISOString(),
+                halfOpen: true,
+                observedDelayMs: nowMs - eventMs,
+                lateEntryPolicy: 'do_not_chase',
+            },
+            accountAdmission: {
+                available: book.available
+                    && lockedState.state === 'active'
+                    && !pendingReversalRelease,
+                source: snapshot.source,
+                cashEquityUsd: snapshot.cashEquityUsd ?? null,
+                reasons: book.reasons,
+                limitations: book.limitations,
+            },
+            decisions,
+            authorizations: {
+                entries: issuedEntries,
+                exits: issuedExits,
+                supportedModes: ['PAPER', 'LIVE'],
+                orderMutationPerformed: false,
+            },
+        };
+    });
+}