@reefclaw/connect 0.1.10 → 0.1.12

package/assets/plugin/tools/get-wave9-status.js

@@ -1,796 +0,0 @@
-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,
-            },
-        };
-    });
-}