@reefclaw/openclaw-plugin 0.1.5 → 0.1.6

package/wave9/live-startup-reconciliation.js

@@ -0,0 +1,454 @@
+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/wave9/live-symbol-ownership.d.ts

@@ -0,0 +1,20 @@
+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/wave9/live-symbol-ownership.js

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