@reefclaw/connect 0.1.10 → 0.1.12

package/assets/plugin/wave9/live-startup-reconciliation.js

@@ -1,454 +0,0 @@
-import { formatError } from '../logger.js';
-import { confirmWave9LiveNativeStop, } from './live-account-capture.js';
-import { recoverWave9LiveExposure, } from './live-autonomous-protection.js';
-import { confirmWave9LivePositionFlat, } from './live-position-confirmation.js';
-function canonicalSymbol(symbol) {
-    return symbol.toUpperCase().replace(/[^A-Z0-9]/g, '').replace(/USDTUSDT$/, 'USDT');
-}
-function sameQuantity(left, right) {
-    return Math.abs(left - right) <= 1e-9 * Math.max(1, Math.abs(left), Math.abs(right));
-}
-function maximumCandidateQuantity(record) {
-    return record.filledQuantity ?? record.quantity;
-}
-function manual(record, detail, retryable = false) {
-    return {
-        candidateId: record.candidateId,
-        symbol: record.symbol,
-        priorState: record.state,
-        status: 'manual_intervention',
-        detail: `IMMEDIATE MANUAL INTERVENTION REQUIRED: ${detail}`,
-        retryable,
-    };
-}
-function validateExactOrderIdentity(record, order) {
-    if (order.clientOrderId !== record.clientOrderId) {
-        return `exact-CID lookup returned clientOrderId ${order.clientOrderId ?? 'missing'}`;
-    }
-    if (canonicalSymbol(order.symbol) !== record.symbol) {
-        return `exact-CID lookup returned symbol ${order.symbol}, expected ${record.symbol}`;
-    }
-    if (order.side !== record.side) {
-        return `exact-CID lookup returned side ${order.side}, expected ${record.side}`;
-    }
-    if (order.type !== 'market') {
-        return `exact-CID lookup returned non-market order type ${order.type}`;
-    }
-    if (order.status !== 'open' && order.status !== 'closed' && order.status !== 'canceled') {
-        return `exact-CID lookup returned malformed/unsupported status ${String(order.status)}`;
-    }
-    if (!confirmedExchangeOrderId(order)) {
-        return 'exact-CID lookup returned a malformed exchange order ID';
-    }
-    if (typeof order.amount !== 'number' || !Number.isFinite(order.amount) || order.amount <= 0) {
-        return 'exact-CID lookup returned a malformed order amount';
-    }
-    if (order.amount > record.quantity) {
-        return `exact-CID amount ${order.amount} exceeds authorized quantity ${record.quantity}`;
-    }
-    if (typeof order.filled !== 'number' || !Number.isFinite(order.filled) || order.filled < 0) {
-        return 'exact-CID lookup returned a malformed filled quantity';
-    }
-    if (order.filled > order.amount) {
-        return `exact-CID fill ${order.filled} exceeds its order amount ${order.amount}`;
-    }
-    if (order.filled > record.quantity) {
-        return `exact-CID fill ${order.filled} exceeds authorized quantity ${record.quantity}`;
-    }
-    if (record.state === 'open'
-        && record.filledQuantity !== undefined
-        && order.filled < record.filledQuantity) {
-        return `exact-CID fill ${order.filled} decreases durable fill ${record.filledQuantity}`;
-    }
-    if (record.state === 'open'
-        && record.exchangeOrderId !== undefined
-        && order.id !== record.exchangeOrderId) {
-        return `exact-CID exchange order ${order.id} disagrees with durable order ${record.exchangeOrderId}`;
-    }
-    return undefined;
-}
-async function resolveExactOrder(adapter, record) {
-    if (!adapter.resolveOrderByClientId) {
-        return { status: 'unknown', detail: 'deterministic client-order resolver is unavailable' };
-    }
-    let resolution;
-    try {
-        resolution = await adapter.resolveOrderByClientId(record.clientOrderId, record.symbol);
-    }
-    catch (error) {
-        return { status: 'unknown', detail: `exact-CID lookup threw: ${formatError(error)}` };
-    }
-    if (resolution.status === 'unknown')
-        return resolution;
-    if (resolution.status === 'confirmed_absent')
-        return resolution;
-    const mismatch = validateExactOrderIdentity(record, resolution.order);
-    return mismatch
-        ? { status: 'mismatch', detail: mismatch }
-        : { status: 'found', order: resolution.order };
-}
-/**
- * A crash may leave the deterministic entry order open with an unfilled
- * remainder. Cancel only that exact candidate-bound order before interpreting
- * its final fill; never submit a replacement entry during recovery.
- */
-async function terminalizeOpenRemainder(adapter, record, observation) {
-    if (observation.status !== 'found' || observation.order.status !== 'open') {
-        return observation;
-    }
-    let cancelError;
-    try {
-        await adapter.cancelOrder(observation.order.id, record.symbol);
-    }
-    catch (error) {
-        // A post-submit error is ambiguous. The second exact lookup below, not
-        // the exception, determines whether the remainder is terminal.
-        cancelError = formatError(error);
-    }
-    const settled = await resolveExactOrder(adapter, record);
-    if (settled.status !== 'found') {
-        return settled.status === 'mismatch'
-            ? settled
-            : {
-                status: 'unknown',
-                detail: `exact entry remainder cancellation ${cancelError ? `threw (${cancelError})` : 'was acknowledged'}, ` +
-                    `but terminal exact-CID state is ${settled.status}`,
-            };
-    }
-    if (settled.order.status === 'open') {
-        return {
-            status: 'unknown',
-            detail: `exact candidate entry ${record.clientOrderId} still has an open remainder` +
-                `${cancelError ? ` after cancellation threw (${cancelError})` : ''}`,
-        };
-    }
-    return settled;
-}
-async function observePositionIdentity(adapter, record, maximumQuantity) {
-    let positions;
-    try {
-        positions = await adapter.getPositionsOrNull(record.symbol);
-    }
-    catch (error) {
-        return { status: 'unknown', detail: `position lookup threw: ${formatError(error)}` };
-    }
-    if (positions === null || !Array.isArray(positions)) {
-        return { status: 'unknown', detail: 'position state is unavailable' };
-    }
-    const matches = [];
-    for (const position of positions) {
-        if (!position
-            || typeof position.symbol !== 'string'
-            || (position.side !== 'long' && position.side !== 'short')
-            || typeof position.contracts !== 'number'
-            || !Number.isFinite(position.contracts)
-            || position.contracts < 0) {
-            return { status: 'unknown', detail: 'position snapshot contains malformed rows' };
-        }
-        if (canonicalSymbol(position.symbol) === record.symbol && position.contracts > 0) {
-            matches.push(position);
-        }
-    }
-    if (matches.length === 0) {
-        return { status: 'flat', detail: 'one trusted position snapshot is currently flat' };
-    }
-    if (matches.length !== 1) {
-        return { status: 'mismatch', detail: 'multiple same-symbol exchange positions are visible' };
-    }
-    const position = matches[0];
-    const expectedSide = record.side === 'buy' ? 'long' : 'short';
-    if (position.side !== expectedSide) {
-        return {
-            status: 'mismatch',
-            detail: `same-symbol position side ${position.side} does not match ${expectedSide}`,
-        };
-    }
-    if (position.contracts > maximumQuantity
-        && !sameQuantity(position.contracts, maximumQuantity)) {
-        return {
-            status: 'mismatch',
-            detail: `same-symbol quantity ${position.contracts} exceeds exact candidate fill/authorization ` +
-                `${maximumQuantity}`,
-        };
-    }
-    if (position.candidateId && position.candidateId !== record.candidateId) {
-        return {
-            status: 'mismatch',
-            detail: `position candidate ${position.candidateId} disagrees with ${record.candidateId}`,
-        };
-    }
-    if (position.missionId && position.missionId !== record.missionId) {
-        return {
-            status: 'mismatch',
-            detail: `position mission ${position.missionId} disagrees with ${record.missionId}`,
-        };
-    }
-    if (position.strategy && position.strategy !== record.strategy) {
-        return {
-            status: 'mismatch',
-            detail: `position strategy ${position.strategy} disagrees with ${record.strategy}`,
-        };
-    }
-    return {
-        status: 'matching',
-        detail: `one trusted ${expectedSide} position has ${position.contracts} contracts within ` +
-            `candidate maximum ${maximumQuantity}`,
-        quantity: position.contracts,
-    };
-}
-async function exactNativeStopAlreadyProtectsOpenRow(adapter, record, position, confirmStop) {
-    if (record.state !== 'open' || position.status !== 'matching')
-        return false;
-    const quantities = [...new Set([
-            maximumCandidateQuantity(record),
-            position.quantity,
-        ])];
-    for (const filledQuantity of quantities) {
-        try {
-            if (await confirmStop(adapter, {
-                candidateId: record.candidateId,
-                symbol: record.symbol,
-                entryClientOrderId: record.clientOrderId,
-                entrySide: record.side,
-                stopPrice: record.initialStop,
-                filledQuantity,
-            }))
-                return true;
-        }
-        catch {
-            // An old entry may no longer be queryable. Only positive exact native
-            // stop proof is accepted; a failed proof falls through to entry lookup.
-        }
-    }
-    return false;
-}
-function confirmedEntryPrice(order, record) {
-    const candidates = [order.average, order.price];
-    for (const value of candidates) {
-        if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
-            continue;
-        if ((record.side === 'buy' && value > record.initialStop)
-            || (record.side === 'sell' && value < record.initialStop))
-            return value;
-    }
-    return undefined;
-}
-function confirmedExchangeOrderId(order) {
-    return typeof order.id === 'string'
-        && order.id.length > 0
-        && order.id.length <= 512
-        && order.id.trim() === order.id
-        ? order.id
-        : undefined;
-}
-async function persistClosed(ledger, record, detail) {
-    try {
-        ledger.markClosed(record.candidateId);
-        return {
-            candidateId: record.candidateId,
-            symbol: record.symbol,
-            priorState: record.state,
-            status: 'closed',
-            detail,
-            retryable: false,
-        };
-    }
-    catch (error) {
-        return manual(record, `stable flatness was proven, but durable CLOSED persistence failed: ${formatError(error)}`);
-    }
-}
-async function establishDurableFill(ledger, record, order) {
-    const entryPrice = confirmedEntryPrice(order, record);
-    const exchangeOrderId = confirmedExchangeOrderId(order);
-    try {
-        if (record.state === 'attempted') {
-            ledger.markOpen(record.candidateId, {
-                filledQuantity: order.filled,
-                ...(entryPrice !== undefined ? { entryPrice } : {}),
-                exchangeOrderId,
-            });
-        }
-        else {
-            ledger.reconcileOpenFillFromExactOrder(record.candidateId, {
-                filledQuantity: order.filled,
-                exchangeOrderId,
-                ...(entryPrice !== undefined ? { entryPrice } : {}),
-            });
-        }
-        return undefined;
-    }
-    catch (error) {
-        return formatError(error);
-    }
-}
-async function reconcileResolvedFill(adapter, ledger, record, order, initialPosition, options) {
-    let position = initialPosition;
-    if (position.status === 'mismatch') {
-        return manual(record, `exact CID proves a fill, but current exposure identity is mismatched: ${position.detail}; ` +
-            'refusing same-symbol stop replacement or close');
-    }
-    if (position.status !== 'matching') {
-        const flat = await options.confirmFlat(adapter, record.symbol, options.flatConfirmation);
-        if (flat.confirmed) {
-            const openError = await establishDurableFill(ledger, record, order);
-            if (openError) {
-                return manual(record, `exact fill was proven, but durable OPEN persistence failed: ${openError}`);
-            }
-            return persistClosed(ledger, record, `exact CID proves the historical fill and exchange flatness remained stable (${flat.detail})`);
-        }
-        position = await observePositionIdentity(adapter, record, order.filled);
-        if (position.status !== 'matching') {
-            return manual(record, `exact CID proves a fill, but no candidate-bound residual can be safely recovered: ` +
-                `${position.detail}; stable flatness was not proven (${flat.detail})`, position.status === 'unknown' || position.status === 'flat');
-        }
-    }
-    const openError = await establishDurableFill(ledger, record, order);
-    if (openError) {
-        return manual(record, `exact fill and residual were proven, but durable OPEN persistence failed: ${openError}; ` +
-            'refusing exchange mutation without durable ownership');
-    }
-    const fenceState = { current: position };
-    const authorizeExposureMutation = async () => {
-        fenceState.current = await observePositionIdentity(adapter, record, order.filled);
-        return {
-            authorized: fenceState.current.status === 'matching',
-            detail: fenceState.current.detail,
-        };
-    };
-    let recovery;
-    try {
-        recovery = await options.recoverExposure(adapter, ledger, record.candidateId, record.symbol, {
-            ...options.recoveryOptions,
-            authorizeExposureMutation,
-        });
-    }
-    catch (error) {
-        return manual(record, `candidate-bound startup recovery threw: ${formatError(error)}`);
-    }
-    if (recovery.status === 'flat') {
-        return {
-            candidateId: record.candidateId,
-            symbol: record.symbol,
-            priorState: record.state,
-            status: 'closed',
-            detail: recovery.detail,
-            retryable: false,
-        };
-    }
-    if (recovery.status === 'protected') {
-        return {
-            candidateId: record.candidateId,
-            symbol: record.symbol,
-            priorState: record.state,
-            status: 'protected',
-            detail: recovery.detail,
-            retryable: false,
-        };
-    }
-    return manual(record, recovery.detail, fenceState.current.status === 'unknown' || fenceState.current.status === 'flat');
-}
-async function reconcileRow(adapter, ledger, record, options) {
-    const durableMaximum = maximumCandidateQuantity(record);
-    let position = await observePositionIdentity(adapter, record, durableMaximum);
-    // Historical entry lookup on Binance is not an eternal data source. A
-    // positive proof of the exact candidate-bound native close-all stop plus a
-    // compatible trusted position is enough to retain an already-safe OPEN row.
-    const exactStopProven = await exactNativeStopAlreadyProtectsOpenRow(adapter, record, position, options.confirmStop);
-    const durableFillIsComplete = record.state === 'open'
-        && record.filledQuantity !== undefined
-        && sameQuantity(record.filledQuantity, record.quantity);
-    if (exactStopProven && durableFillIsComplete) {
-        return {
-            candidateId: record.candidateId,
-            symbol: record.symbol,
-            priorState: 'open',
-            status: 'protected',
-            detail: 'existing exact candidate-bound native close-all stop is proven live',
-            retryable: false,
-        };
-    }
-    let exact = await resolveExactOrder(adapter, record);
-    if (exact.status === 'mismatch') {
-        return manual(record, `${exact.detail}; refusing to attribute or mutate same-symbol exposure`);
-    }
-    if (exact.status === 'unknown') {
-        return manual(record, exactStopProven
-            ? `${exact.detail}; an exact native close-all stop protects the currently observed residual, ` +
-                'but the partial/missing durable fill cannot bypass terminal entry-remainder proof'
-            : exact.detail, true);
-    }
-    if (exact.status === 'confirmed_absent') {
-        const flat = await options.confirmFlat(adapter, record.symbol, options.flatConfirmation);
-        if (flat.confirmed) {
-            return persistClosed(ledger, record, `exact entry CID is confirmed absent and exchange flatness remained stable (${flat.detail})`);
-        }
-        position = await observePositionIdentity(adapter, record, durableMaximum);
-        return manual(record, `exact entry CID is confirmed absent, so current same-symbol exposure is not attributed ` +
-            `to Wave 9; stable flatness was not proven (${flat.detail}; ${position.detail})`, position.status === 'unknown' || position.status === 'flat');
-    }
-    exact = await terminalizeOpenRemainder(adapter, record, exact);
-    if (exact.status === 'mismatch') {
-        return manual(record, `${exact.detail}; refusing to attribute or mutate same-symbol exposure`);
-    }
-    if (exact.status === 'unknown' || exact.status === 'confirmed_absent') {
-        return manual(record, exact.status === 'unknown'
-            ? exact.detail
-            : 'a previously found exact entry became absent before terminal state was proven', true);
-    }
-    if (exact.order.filled === 0) {
-        const flat = await options.confirmFlat(adapter, record.symbol, options.flatConfirmation);
-        if (flat.confirmed) {
-            return persistClosed(ledger, record, `exact entry is terminal with zero fill and exchange flatness remained stable (${flat.detail})`);
-        }
-        position = await observePositionIdentity(adapter, record, durableMaximum);
-        return manual(record, `exact entry is terminal with zero fill, so current same-symbol exposure is not attributed ` +
-            `to Wave 9; stable flatness was not proven (${flat.detail}; ${position.detail})`, position.status === 'unknown' || position.status === 'flat');
-    }
-    position = await observePositionIdentity(adapter, record, exact.order.filled);
-    return reconcileResolvedFill(adapter, ledger, record, exact.order, position, options);
-}
-/**
- * Reconcile crash-ambiguous durable Wave 9 rows after a LIVE adapter reaches
- * READY. The caller must hold the shared trading-operation lock. This function
- * never submits another entry. It only cancels an exact candidate entry
- * remainder, persists stably-flat terminal state, or repairs/flattens exposure
- * after exact entry-CID and current-position identity both agree.
- */
-export async function reconcileWave9LiveDurableRows(adapter, ledger, options = {}) {
-    if (!adapter.isLive || adapter.mode !== 'LIVE' || adapter.readiness !== 'READY') {
-        throw new Error(`Wave 9 startup reconciliation requires the current LIVE adapter READY ` +
-            `(isLive=${adapter.isLive}, mode=${adapter.mode}, readiness=${adapter.readiness})`);
-    }
-    const effective = {
-        ...options,
-        confirmFlat: options.confirmFlat ?? confirmWave9LivePositionFlat,
-        confirmStop: options.confirmStop ?? confirmWave9LiveNativeStop,
-        recoverExposure: options.recoverExposure ?? recoverWave9LiveExposure,
-    };
-    const unresolved = ledger.getAll().filter((record) => record.state === 'attempted' || record.state === 'open');
-    const conflicts = new Set();
-    const counts = new Map();
-    for (const record of unresolved) {
-        counts.set(record.symbol, (counts.get(record.symbol) ?? 0) + 1);
-    }
-    for (const [symbol, count] of counts) {
-        if (count > 1)
-            conflicts.add(symbol);
-    }
-    const rows = [];
-    for (const record of unresolved) {
-        if (conflicts.has(record.symbol)) {
-            rows.push(manual(record, `multiple unresolved durable Wave 9 rows claim ${record.symbol}; refusing ambiguous recovery`));
-            continue;
-        }
-        rows.push(await reconcileRow(adapter, ledger, record, effective));
-    }
-    return {
-        rows,
-        unresolvedCount: rows.length,
-        protectedCount: rows.filter((row) => row.status === 'protected').length,
-        closedCount: rows.filter((row) => row.status === 'closed').length,
-        manualInterventionCount: rows.filter((row) => row.status === 'manual_intervention').length,
-        retryable: rows.some((row) => row.retryable),
-    };
-}

package/assets/plugin/wave9/live-symbol-ownership.d.ts

@@ -1,20 +0,0 @@
-import type { IExchangeAdapter } from '../exchange-adapter.js';
-import type { Wave9LiveExecutionLedger } from './live-execution-ledger.js';
-export type Wave9LiveSymbolOwnershipStatus = 'unavailable' | 'unowned' | 'owned' | 'ambiguous';
-export interface Wave9LiveSymbolOwnership {
-    status: Wave9LiveSymbolOwnershipStatus;
-    reason: string;
-    candidateId?: string;
-}
-export type Wave9LiveSymbolOwnershipCheck = (symbol: string) => Promise<Wave9LiveSymbolOwnership>;
-/**
- * Resolve same-symbol ownership from the durable LIVE execution ledger and an
- * exchange-authoritative account capture. Only confirmed-open ledger rows can
- * own a symbol. An attempted-only row is a crash-ambiguous execution outcome,
- * so it blocks generic mutation until repeated trusted snapshots prove the
- * symbol flat and the durable tombstone is retired. A stably flat exchange
- * symbol also retires stale open rows left by a native stop/target close before
- * it is treated as unowned. Any position-present identity disagreement fails
- * closed as ambiguous.
- */
-export declare function inspectWave9LiveSymbolOwnership(adapter: IExchangeAdapter, ledger: Wave9LiveExecutionLedger, symbol: string): Promise<Wave9LiveSymbolOwnership>;

package/assets/plugin/wave9/live-symbol-ownership.js

@@ -1,132 +0,0 @@
-import { WAVE9_BUNDLE_SETUP_TYPE } from './paper-admission-guard.js';
-import { captureWave9LiveAccount } from './live-account-capture.js';
-import { confirmWave9LivePositionFlat } from './live-position-confirmation.js';
-function canonicalSymbol(symbol) {
-    return symbol.toUpperCase().replace(/[^A-Z0-9]/g, '').replace(/USDTUSDT$/, 'USDT');
-}
-function expectedPositionSide(record) {
-    return record.side === 'buy' ? 'long' : 'short';
-}
-async function proveAttemptDidNotCreateExposure(adapter, record) {
-    if (!adapter.resolveOrderByClientId)
-        return false;
-    let resolution;
-    try {
-        resolution = await adapter.resolveOrderByClientId(record.clientOrderId, record.symbol);
-    }
-    catch {
-        return false;
-    }
-    if (resolution.status === 'confirmed_absent')
-        return true;
-    if (resolution.status !== 'found')
-        return false;
-    const order = resolution.order;
-    const filled = order.filled;
-    return order.clientOrderId === record.clientOrderId
-        && canonicalSymbol(order.symbol) === canonicalSymbol(record.symbol)
-        && order.side === record.side
-        && order.status === 'canceled'
-        && typeof filled === 'number'
-        && Number.isFinite(filled)
-        && filled === 0;
-}
-async function proveAttemptsDidNotCreateExposure(adapter, records) {
-    const proofs = await Promise.all(records.map((record) => proveAttemptDidNotCreateExposure(adapter, record)));
-    return proofs.every(Boolean);
-}
-/**
- * Resolve same-symbol ownership from the durable LIVE execution ledger and an
- * exchange-authoritative account capture. Only confirmed-open ledger rows can
- * own a symbol. An attempted-only row is a crash-ambiguous execution outcome,
- * so it blocks generic mutation until repeated trusted snapshots prove the
- * symbol flat and the durable tombstone is retired. A stably flat exchange
- * symbol also retires stale open rows left by a native stop/target close before
- * it is treated as unowned. Any position-present identity disagreement fails
- * closed as ambiguous.
- */
-export async function inspectWave9LiveSymbolOwnership(adapter, ledger, symbol) {
-    const canonical = canonicalSymbol(symbol);
-    const symbolRecords = ledger.getAll().filter((record) => canonicalSymbol(record.symbol) === canonical);
-    const durableOwners = symbolRecords.filter((record) => record.state === 'open');
-    const unresolvedAttempts = symbolRecords.filter((record) => record.state === 'attempted');
-    if (durableOwners.length === 0) {
-        if (unresolvedAttempts.length > 0) {
-            if (!await proveAttemptsDidNotCreateExposure(adapter, unresolvedAttempts)) {
-                return {
-                    status: 'ambiguous',
-                    reason: 'attempted_execution_outcome_not_proven_non_executing',
-                };
-            }
-            const flat = await confirmWave9LivePositionFlat(adapter, symbol);
-            if (!flat.confirmed) {
-                return {
-                    status: 'ambiguous',
-                    reason: 'attempted_execution_outcome_with_live_or_unknown_position',
-                };
-            }
-            try {
-                for (const attempt of unresolvedAttempts)
-                    ledger.markClosed(attempt.candidateId);
-            }
-            catch {
-                return {
-                    status: 'ambiguous',
-                    reason: 'authoritative_attempted_flat_ledger_reconciliation_failed',
-                };
-            }
-            return { status: 'unowned', reason: 'authoritative_attempted_symbol_flat' };
-        }
-        return { status: 'unowned', reason: 'no_durable_open_wave9_record' };
-    }
-    let capture;
-    try {
-        capture = await captureWave9LiveAccount(adapter, ledger, 'LIVE');
-    }
-    catch {
-        return { status: 'ambiguous', reason: 'authoritative_live_capture_failed' };
-    }
-    const positions = capture.positions.filter((position) => canonicalSymbol(position.symbol) === canonical);
-    if (positions.length === 0) {
-        const flat = await confirmWave9LivePositionFlat(adapter, symbol);
-        if (!flat.confirmed) {
-            return { status: 'ambiguous', reason: 'authoritative_flat_not_stably_confirmed' };
-        }
-        if (unresolvedAttempts.length > 0
-            && !await proveAttemptsDidNotCreateExposure(adapter, unresolvedAttempts)) {
-            return {
-                status: 'ambiguous',
-                reason: 'attempted_execution_outcome_not_proven_non_executing',
-            };
-        }
-        try {
-            for (const row of [...durableOwners, ...unresolvedAttempts]) {
-                ledger.markClosed(row.candidateId);
-            }
-        }
-        catch {
-            return { status: 'ambiguous', reason: 'authoritative_flat_ledger_reconciliation_failed' };
-        }
-        return { status: 'unowned', reason: 'authoritative_symbol_flat' };
-    }
-    if (durableOwners.length !== 1) {
-        return { status: 'ambiguous', reason: 'multiple_durable_open_wave9_records' };
-    }
-    if (positions.length !== 1) {
-        return { status: 'ambiguous', reason: 'multiple_exchange_positions_on_owned_symbol' };
-    }
-    const owner = durableOwners[0];
-    const position = positions[0];
-    if (position.candidateId !== owner.candidateId
-        || position.missionId !== owner.missionId
-        || position.setupType !== WAVE9_BUNDLE_SETUP_TYPE
-        || position.strategy !== owner.strategy
-        || position.side !== expectedPositionSide(owner)) {
-        return { status: 'ambiguous', reason: 'exchange_position_identity_mismatch' };
-    }
-    return {
-        status: 'owned',
-        reason: 'durable_open_record_matches_exchange_position',
-        candidateId: owner.candidateId,
-    };
-}