@stelis/say-ur-intent 0.0.0 → 0.0.2

package/dist/runtime/smokeMainnetReadAssertions.js

@@ -0,0 +1,308 @@
+export class SmokeResponseShapeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SmokeResponseShapeError";
+    }
+}
+export function assertSmokeOkStatus(payload, toolName) {
+    const data = objectValue(payload.data);
+    if (payload.ok !== true || data?.status !== "ok") {
+        throw new SmokeResponseShapeError(`Tool ${toolName} did not return ok status: ${JSON.stringify(payload)}`);
+    }
+}
+export function summarizeActivitySmokePayload(payload, toolName, options) {
+    assertSmokeOkStatus(payload, toolName);
+    const data = requiredObject(payload.data, `${toolName}.data`);
+    const source = requiredObject(data.source, `${toolName}.data.source`);
+    const persistence = requiredObject(data.persistence, `${toolName}.data.persistence`);
+    const requestedAccount = requiredObject(data.requestedAccount, `${toolName}.data.requestedAccount`);
+    const transactions = requiredArray(data.transactions, `${toolName}.data.transactions`);
+    const account = requiredString(data.account, `${toolName}.data.account`);
+    const accountSource = requiredAccountSource(data.accountSource, `${toolName}.data.accountSource`);
+    const relationship = requiredRelationship(data.relationship, `${toolName}.data.relationship`);
+    const functionTarget = options.requireFunction
+        ? requiredString(data.function, `${toolName}.data.function`)
+        : undefined;
+    const sourceTransport = requiredLiteral(source.transport, "graphql", `${toolName}.data.source.transport`);
+    const sourceMethod = requiredLiteral(source.method, "Query.transactions", `${toolName}.data.source.method`);
+    const hasMore = requiredBoolean(data.hasMore, `${toolName}.data.hasMore`);
+    const windowComplete = requiredBooleanOrNull(data.windowComplete, `${toolName}.data.windowComplete`);
+    const orderingVerified = requiredBoolean(data.orderingVerified, `${toolName}.data.orderingVerified`);
+    const persistenceStored = requiredBoolean(persistence.stored, `${toolName}.data.persistence.stored`);
+    const requestedAccountBalanceChangeCompleteness = requiredBalanceChangeCompleteness(requestedAccount.balanceChangeCompleteness, `${toolName}.data.requestedAccount.balanceChangeCompleteness`);
+    const requestedAccountCoinFlows = requiredArray(requestedAccount.coinFlows, `${toolName}.data.requestedAccount.coinFlows`);
+    const requestedAccountSentCount = requiredNonnegativeInteger(requestedAccount.sentCount, `${toolName}.data.requestedAccount.sentCount`);
+    const requestedAccountAffectedOnlyCount = requiredNonnegativeInteger(requestedAccount.affectedOnlyCount, `${toolName}.data.requestedAccount.affectedOnlyCount`);
+    const requestedAccountTransactionFacts = requiredArray(data.requestedAccountTransactionFacts, `${toolName}.data.requestedAccountTransactionFacts`);
+    const accountFactSummary = summarizeRequestedAccountTransactionFacts(requestedAccountTransactionFacts, transactions.length, toolName);
+    const compactSummary = summarizeCompactResponseSupport(transactions, toolName);
+    let analysisLimitationCount;
+    let analysisCoinFlowCount;
+    if (accountSource !== options.expectedAccountSource) {
+        throw new SmokeResponseShapeError(`${toolName}.data.accountSource expected ${options.expectedAccountSource}, got ${accountSource}`);
+    }
+    if (options.expectedRelationship !== undefined && relationship !== options.expectedRelationship) {
+        throw new SmokeResponseShapeError(`${toolName}.data.relationship expected ${options.expectedRelationship}, got ${relationship}`);
+    }
+    if (options.requireAnalysis) {
+        const analysis = requiredObject(data.analysis, `${toolName}.data.analysis`);
+        const overview = requiredObject(analysis.overview, `${toolName}.data.analysis.overview`);
+        const limitations = requiredArray(analysis.limitations, `${toolName}.data.analysis.limitations`);
+        const coinFlows = requiredArray(analysis.coinFlows, `${toolName}.data.analysis.coinFlows`);
+        const analysisTransactionCount = requiredNonnegativeInteger(overview.transactionCount, `${toolName}.data.analysis.overview.transactionCount`);
+        if (analysisTransactionCount !== transactions.length) {
+            throw new SmokeResponseShapeError(`${toolName}.data.analysis.overview.transactionCount does not match transactions.length`);
+        }
+        analysisLimitationCount = limitations.length;
+        analysisCoinFlowCount = coinFlows.length;
+    }
+    if (options.expectNoDetails === true && compactSummary.fullDetailsReturned) {
+        throw new SmokeResponseShapeError(`${toolName}.data.transactions must not include full details`);
+    }
+    if (options.expectNoDetails === true && compactSummary.compactReturned) {
+        throw new SmokeResponseShapeError(`${toolName}.data.transactions must not include compact transaction aggregates`);
+    }
+    return {
+        status: transactions.length === 0 ? "empty_page" : "ok",
+        rowCount: transactions.length,
+        emptyAccepted: transactions.length === 0,
+        transactionCount: transactions.length,
+        account,
+        accountSource,
+        relationship,
+        ...(functionTarget === undefined ? {} : { functionTargetPresent: true }),
+        sourceTransport,
+        sourceMethod,
+        hasMore,
+        windowComplete,
+        orderingVerified,
+        persistenceStored,
+        requestedAccountBalanceChangeCompleteness,
+        requestedAccountCoinFlowCount: requestedAccountCoinFlows.length,
+        requestedAccountSentCount,
+        requestedAccountAffectedOnlyCount,
+        ...accountFactSummary,
+        ...compactSummary,
+        ...(analysisLimitationCount === undefined ? {} : { analysisLimitationCount }),
+        ...(analysisCoinFlowCount === undefined ? {} : { analysisCoinFlowCount })
+    };
+}
+function summarizeRequestedAccountTransactionFacts(facts, transactionCount, toolName) {
+    if (facts.length !== transactionCount) {
+        throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts length does not match transactions.length`);
+    }
+    let balanceChangeRows = 0;
+    facts.forEach((factValue, factIndex) => {
+        const fact = requiredObject(factValue, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}]`);
+        const requestedAccountEffect = requiredObject(fact.requestedAccountEffect, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].requestedAccountEffect`);
+        const evidence = requiredAccountBalanceChangeEvidence(fact.accountBalanceChangeEvidence, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].accountBalanceChangeEvidence`);
+        const absenceProven = requiredBoolean(fact.accountBalanceChangeAbsenceProven, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].accountBalanceChangeAbsenceProven`);
+        const inferencePolicy = requiredAccountBalanceChangeInferencePolicy(fact.accountBalanceChangeInferencePolicy, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].accountBalanceChangeInferencePolicy`);
+        const completeness = requiredBalanceChangeCompleteness(fact.accountBalanceChangeCompleteness, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].accountBalanceChangeCompleteness`);
+        requiredLiteral(requestedAccountEffect.scope, "requested_account", `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].requestedAccountEffect.scope`);
+        const balanceChanges = requiredArray(fact.accountBalanceChanges, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].accountBalanceChanges`);
+        balanceChangeRows += balanceChanges.length;
+        const nestedBalanceChanges = requiredArray(requestedAccountEffect.balanceChanges, `${toolName}.data.requestedAccountTransactionFacts[${factIndex}].requestedAccountEffect.balanceChanges`);
+        if (nestedBalanceChanges.length !== balanceChanges.length) {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}] accountBalanceChanges length must match requestedAccountEffect.balanceChanges length`);
+        }
+        if (completeness === "truncated" && evidence !== "incomplete_account_balance_changes") {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}] truncated account evidence must be incomplete_account_balance_changes`);
+        }
+        if (completeness === "unavailable" && evidence !== "account_balance_changes_unavailable") {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}] unavailable account evidence must be account_balance_changes_unavailable`);
+        }
+        if (completeness === "complete" && balanceChanges.length === 0 && evidence !== "no_account_balance_changes_returned") {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}] empty complete account evidence must be no_account_balance_changes_returned`);
+        }
+        const expectedAbsenceProven = completeness === "complete" && balanceChanges.length === 0;
+        if (absenceProven !== expectedAbsenceProven) {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}].accountBalanceChangeAbsenceProven is inconsistent with evidence completeness and row count`);
+        }
+        if (requestedAccountEffect.accountBalanceChangeAbsenceProven !== absenceProven) {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}].requestedAccountEffect.accountBalanceChangeAbsenceProven does not match flat field`);
+        }
+        const expectedInferencePolicy = expectedAccountBalanceChangeInferencePolicy(evidence, absenceProven);
+        if (inferencePolicy !== expectedInferencePolicy) {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}].accountBalanceChangeInferencePolicy is inconsistent with account evidence`);
+        }
+        if (requestedAccountEffect.accountBalanceChangeInferencePolicy !== inferencePolicy) {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}].requestedAccountEffect.accountBalanceChangeInferencePolicy does not match flat field`);
+        }
+        const transactionContext = objectValue(fact.transactionContext);
+        if (transactionContext !== undefined && Object.hasOwn(transactionContext, "balanceChanges")) {
+            throw new SmokeResponseShapeError(`${toolName}.data.requestedAccountTransactionFacts[${factIndex}].transactionContext must not include transaction-wide balanceChanges`);
+        }
+    });
+    return {
+        requestedAccountTransactionFactCount: facts.length,
+        requestedAccountTransactionFactBalanceChangeRowCount: balanceChangeRows
+    };
+}
+function summarizeCompactResponseSupport(transactions, toolName) {
+    let fullDetailsReturned = false;
+    let compactReturned = false;
+    let compactBalanceChangeRowCount = 0;
+    let compactAggregatedBalanceChangeRowCount = 0;
+    let transactionContextCount = 0;
+    let requestedAccountEffectBalanceChangeRowCount = 0;
+    let requestedAccountEffectTruncatedTransactionCount = 0;
+    transactions.forEach((transactionValue, transactionIndex) => {
+        const transaction = requiredObject(transactionValue, `${toolName}.data.transactions[${transactionIndex}]`);
+        if (Object.hasOwn(transaction, "details")) {
+            fullDetailsReturned = true;
+        }
+        const transactionContext = objectValue(transaction.transactionContext);
+        if (transactionContext !== undefined) {
+            transactionContextCount += 1;
+            if (transactionContext.factScope !== "transaction") {
+                throw new Error(`${toolName}.data.transactions[${transactionIndex}].transactionContext.factScope must be "transaction"`);
+            }
+            if (transactionContext.requestedAccountScoped !== false) {
+                throw new Error(`${toolName}.data.transactions[${transactionIndex}].transactionContext.requestedAccountScoped must be false`);
+            }
+            if (Object.hasOwn(transactionContext, "balanceChanges")) {
+                throw new SmokeResponseShapeError(`${toolName}.data.transactions[${transactionIndex}].transactionContext must not include transaction-wide balanceChanges`);
+            }
+        }
+        const requestedAccountEffect = objectValue(transaction.requestedAccountEffect);
+        if (requestedAccountEffect !== undefined) {
+            requiredLiteral(requestedAccountEffect.scope, "requested_account", `${toolName}.data.transactions[${transactionIndex}].requestedAccountEffect.scope`);
+            const completeness = requiredBalanceChangeCompleteness(requestedAccountEffect.balanceChangeCompleteness, `${toolName}.data.transactions[${transactionIndex}].requestedAccountEffect.balanceChangeCompleteness`);
+            if (completeness === "truncated") {
+                requestedAccountEffectTruncatedTransactionCount += 1;
+            }
+            requestedAccountEffectBalanceChangeRowCount += requiredArray(requestedAccountEffect.balanceChanges, `${toolName}.data.transactions[${transactionIndex}].requestedAccountEffect.balanceChanges`).length;
+        }
+        const compact = objectValue(transaction.compact);
+        if (compact === undefined) {
+            return;
+        }
+        compactReturned = true;
+        if (compact.factScope !== "transaction") {
+            throw new Error(`${toolName}.data.transactions[${transactionIndex}].compact.factScope must be "transaction"`);
+        }
+        if (compact.requestedAccountScoped !== false) {
+            throw new Error(`${toolName}.data.transactions[${transactionIndex}].compact.requestedAccountScoped must be false`);
+        }
+        const balanceChanges = requiredArray(compact.balanceChanges, `${toolName}.data.transactions[${transactionIndex}].compact.balanceChanges`);
+        compactBalanceChangeRowCount += balanceChanges.length;
+        balanceChanges.forEach((changeValue, changeIndex) => {
+            const change = requiredObject(changeValue, `${toolName}.data.transactions[${transactionIndex}].compact.balanceChanges[${changeIndex}]`);
+            if (change.count === undefined) {
+                return;
+            }
+            const count = requiredPositiveInteger(change.count, `${toolName}.data.transactions[${transactionIndex}].compact.balanceChanges[${changeIndex}].count`);
+            if (count > 1) {
+                compactAggregatedBalanceChangeRowCount += 1;
+            }
+        });
+    });
+    return {
+        fullDetailsReturned,
+        compactReturned,
+        compactBalanceChangeRowCount,
+        compactAggregatedBalanceChangeRowCount,
+        transactionContextCount,
+        requestedAccountEffectBalanceChangeRowCount,
+        requestedAccountEffectTruncatedTransactionCount
+    };
+}
+function requiredObject(value, path) {
+    const object = objectValue(value);
+    if (object === undefined) {
+        throw new SmokeResponseShapeError(`${path} must be an object`);
+    }
+    return object;
+}
+function objectValue(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function requiredArray(value, path) {
+    if (!Array.isArray(value)) {
+        throw new SmokeResponseShapeError(`${path} must be an array`);
+    }
+    return value;
+}
+function requiredString(value, path) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new SmokeResponseShapeError(`${path} must be a non-empty string`);
+    }
+    return value;
+}
+function requiredBoolean(value, path) {
+    if (typeof value !== "boolean") {
+        throw new SmokeResponseShapeError(`${path} must be a boolean`);
+    }
+    return value;
+}
+function requiredBooleanOrNull(value, path) {
+    if (typeof value !== "boolean" && value !== null) {
+        throw new SmokeResponseShapeError(`${path} must be a boolean or null`);
+    }
+    return value;
+}
+function requiredNonnegativeInteger(value, path) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+        throw new SmokeResponseShapeError(`${path} must be a nonnegative integer`);
+    }
+    return value;
+}
+function requiredPositiveInteger(value, path) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+        throw new SmokeResponseShapeError(`${path} must be a positive integer`);
+    }
+    return value;
+}
+function requiredAccountSource(value, path) {
+    if (value === "active_account_context" || value === "explicit_filter") {
+        return value;
+    }
+    throw new SmokeResponseShapeError(`${path} must be active_account_context or explicit_filter`);
+}
+function requiredRelationship(value, path) {
+    if (value === "affected" || value === "sent") {
+        return value;
+    }
+    throw new SmokeResponseShapeError(`${path} must be affected or sent`);
+}
+function requiredBalanceChangeCompleteness(value, path) {
+    if (value === "complete" || value === "truncated" || value === "unavailable") {
+        return value;
+    }
+    throw new SmokeResponseShapeError(`${path} must be complete, truncated, or unavailable`);
+}
+function requiredAccountBalanceChangeEvidence(value, path) {
+    if (value === "account_balance_changes_returned" ||
+        value === "no_account_balance_changes_returned" ||
+        value === "incomplete_account_balance_changes" ||
+        value === "account_balance_changes_unavailable") {
+        return value;
+    }
+    throw new SmokeResponseShapeError(`${path} must be a valid account balance-change evidence marker`);
+}
+function requiredAccountBalanceChangeInferencePolicy(value, path) {
+    if (value === "use_returned_account_balance_changes" ||
+        value === "account_absence_proven_by_complete_details" ||
+        value === "do_not_infer_from_transaction_context") {
+        return value;
+    }
+    throw new SmokeResponseShapeError(`${path} must be a valid account balance-change inference policy`);
+}
+function expectedAccountBalanceChangeInferencePolicy(evidence, absenceProven) {
+    if (evidence === "account_balance_changes_returned") {
+        return "use_returned_account_balance_changes";
+    }
+    if (evidence === "no_account_balance_changes_returned" && absenceProven) {
+        return "account_absence_proven_by_complete_details";
+    }
+    return "do_not_infer_from_transaction_context";
+}
+function requiredLiteral(value, expected, path) {
+    if (value === expected) {
+        return expected;
+    }
+    throw new SmokeResponseShapeError(`${path} must be ${expected}`);
+}

package/dist/runtime/start.js

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+import { mainnetCoins } from "@mysten/deepbook-v3";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { SqliteActivityStore } from "../core/activity/sqliteActivityStore.js";
+import { createDeepbookSwapTransactionMaterialDigestProducer, createDeepbookSwapTransactionMaterialProducer } from "../adapters/deepbook/deepbookTransactionMaterialProducer.js";
+import { createDeepbookSwapHumanReadableReviewProducer } from "../adapters/deepbook/deepbookHumanReviewProducer.js";
+import { createFlowxSwapTransactionMaterialDigestProducer, createFlowxSwapTransactionMaterialProducer } from "../adapters/flowx/flowxSwapTransactionMaterialProducer.js";
+import { createFlowxSwapHumanReadableReviewProducer } from "../adapters/flowx/flowxSwapHumanReviewProducer.js";
+import { createFlowxSwapReviewQuoteSource } from "../core/read/flowxQuoteClient.js";
+import { validateSupportedAdapterLifecycle } from "../adapters/adapterLifecycleValidators.js";
+import { buildSupportedReviewAdapters } from "../adapters/reviewAdapters.js";
+import { ADAPTER_PROMPT_SURFACES } from "../adapters/adapterPromptSurfaces.js";
+import { TransactionActivityService } from "../core/activity/transactionActivityService.js";
+import { createSuiReadService } from "../core/read/readService.js";
+import { createTransactionObjectOwnershipProducer } from "../core/action/transactionObjectOwnershipProducer.js";
+import { createReviewTimeSimulationProducer } from "../core/action/reviewTimeSimulationEvidence.js";
+import { producePtbVisualizationArtifact } from "../core/action/ptbVisualizationProducer.js";
+import { InMemoryLocalTransactionMaterialStore } from "../core/session/transactionMaterialStore.js";
+import { InMemorySessionStore } from "../core/session/sessionStore.js";
+import { createMcpServer, startMcp } from "../mcp/server.js";
+import { SERVER_NAME, SERVER_NETWORK, SERVER_VERSION } from "../mcp/serverInfo.js";
+import { createReviewHttpServer } from "../review-server/server.js";
+import { DEFAULT_SUI_GRAPHQL_URL, DEFAULT_SUI_GRPC_URL, composeRuntimeConfig, loadBootConfig } from "./config.js";
+import { probeReviewServerIdentity, startReviewServerWithTakeover, terminateProcessByPid } from "./reviewServerAcquire.js";
+import { RuntimeLocalSettingsService } from "./localSettingsService.js";
+import { createStderrLogger } from "./logger.js";
+import { SuiEndpointError, verifyMainnetGraphqlEndpoint, verifyMainnetGrpcEndpoint } from "./suiEndpoint.js";
+import { GraphqlSuiTransactionActivitySource } from "./suiTransactionGraphqlSource.js";
+async function main() {
+    const logger = createStderrLogger("runtime");
+    let activityStore;
+    let reviewServerForCleanup;
+    let mcp;
+    try {
+        const bootConfig = loadBootConfig();
+        const store = new SqliteActivityStore({
+            databasePath: bootConfig.activityDatabasePath,
+            validateAdapterLifecycle: validateSupportedAdapterLifecycle
+        });
+        activityStore = store;
+        const preferencesRepository = store.createPreferencesRepository();
+        await preferencesRepository.ensureDefaultLocalSettings({
+            suiGrpcUrl: DEFAULT_SUI_GRPC_URL,
+            suiGraphqlUrl: DEFAULT_SUI_GRAPHQL_URL
+        });
+        const storedSuiGrpcUrl = await preferencesRepository.getSuiGrpcUrl();
+        const storedSuiGraphqlUrl = await preferencesRepository.getSuiGraphqlUrl();
+        const config = composeRuntimeConfig({
+            bootConfig,
+            env: process.env,
+            storedSuiGrpcUrl: storedSuiGrpcUrl?.value,
+            storedSuiGraphqlUrl: storedSuiGraphqlUrl?.value,
+            defaultSuiGrpcUrl: DEFAULT_SUI_GRPC_URL,
+            defaultSuiGraphqlUrl: DEFAULT_SUI_GRAPHQL_URL
+        });
+        const { client: suiClient, chainIdentifier } = await verifyMainnetGrpcEndpoint({
+            url: config.grpcUrl,
+            expectedChainIdentifier: config.expectedChainIdentifier
+        });
+        const localSettings = new RuntimeLocalSettingsService({
+            preferencesRepository,
+            env: process.env,
+            defaultSuiGrpcUrl: DEFAULT_SUI_GRPC_URL,
+            defaultSuiGraphqlUrl: DEFAULT_SUI_GRAPHQL_URL,
+            bootSuiGrpcUrl: config.suiGrpcUrl,
+            bootSuiGraphqlUrl: config.suiGraphqlUrl
+        });
+        const localData = store.createLocalDataService({
+            suiGrpcUrl: DEFAULT_SUI_GRPC_URL,
+            suiGraphqlUrl: DEFAULT_SUI_GRAPHQL_URL,
+            verifySuiGrpcUrl: async (url) => {
+                await verifyMainnetGrpcEndpoint({
+                    url,
+                    expectedChainIdentifier: config.expectedChainIdentifier
+                });
+            },
+            verifySuiGraphqlUrl: async (url) => {
+                await verifyMainnetGraphqlEndpoint({
+                    url,
+                    expectedChainIdentifier: config.expectedChainIdentifier
+                });
+            }
+        });
+        const transactionMaterialStore = new InMemoryLocalTransactionMaterialStore();
+        const sessions = new InMemorySessionStore({
+            activityStore: store,
+            transactionMaterialStore,
+            logger,
+            validateAdapterLifecycle: validateSupportedAdapterLifecycle
+        });
+        const readService = createSuiReadService({
+            client: suiClient,
+            network: config.network,
+            chainIdentifier,
+            coinMetadataCache: store.createCoinMetadataCache()
+        });
+        const reviewServerFactory = createReviewHttpServer({
+            host: config.reviewHost,
+            store: sessions,
+            logger,
+            activityStore: store,
+            localSettings,
+            localData,
+            reviewComputationDeps: {
+                validateAdapterLifecycle: validateSupportedAdapterLifecycle,
+                adapters: buildSupportedReviewAdapters((() => {
+                    const transactionObjectOwnershipProducer = createTransactionObjectOwnershipProducer({
+                        materialStore: transactionMaterialStore,
+                        objectSource: suiClient,
+                        network: config.network,
+                        chainIdentifier,
+                        expectedChainIdentifier: config.expectedChainIdentifier
+                    });
+                    const reviewTimeSimulationProducer = createReviewTimeSimulationProducer({
+                        client: suiClient,
+                        materialStore: transactionMaterialStore,
+                        network: config.network,
+                        chainIdentifier,
+                        expectedChainIdentifier: config.expectedChainIdentifier
+                    });
+                    return {
+                        deepbook: {
+                            deepbookQuoteSource: readService,
+                            deepbookDeepBalanceSource: async (account) => {
+                                const balance = await suiClient.core.getBalance({
+                                    owner: account,
+                                    coinType: mainnetCoins.DEEP.type
+                                });
+                                return balance.balance.balance.toString();
+                            },
+                            deepbookTransactionMaterialProducer: createDeepbookSwapTransactionMaterialProducer({
+                                client: suiClient,
+                                network: config.network,
+                                chainIdentifier,
+                                expectedChainIdentifier: config.expectedChainIdentifier,
+                                materialStore: transactionMaterialStore
+                            }),
+                            deepbookTransactionMaterialDigestProducer: createDeepbookSwapTransactionMaterialDigestProducer({
+                                materialStore: transactionMaterialStore
+                            }),
+                            transactionObjectOwnershipProducer,
+                            deepbookHumanReadableReviewProducer: createDeepbookSwapHumanReadableReviewProducer(),
+                            reviewTimeSimulationProducer,
+                            ptbVisualizationProducer: (vizInput) => producePtbVisualizationArtifact({ materialStore: transactionMaterialStore, ...vizInput })
+                        },
+                        flowx: {
+                            flowxQuoteSource: createFlowxSwapReviewQuoteSource(),
+                            flowxTransactionMaterialProducer: createFlowxSwapTransactionMaterialProducer({
+                                client: suiClient,
+                                network: config.network,
+                                chainIdentifier,
+                                expectedChainIdentifier: config.expectedChainIdentifier,
+                                materialStore: transactionMaterialStore
+                            }),
+                            flowxTransactionMaterialDigestProducer: createFlowxSwapTransactionMaterialDigestProducer({
+                                materialStore: transactionMaterialStore
+                            }),
+                            transactionObjectOwnershipProducer,
+                            flowxHumanReadableReviewProducer: createFlowxSwapHumanReadableReviewProducer(),
+                            reviewTimeSimulationProducer,
+                            ptbVisualizationProducer: (vizInput) => producePtbVisualizationArtifact({ materialStore: transactionMaterialStore, ...vizInput })
+                        }
+                    };
+                })())
+            },
+            serverInfo: {
+                name: SERVER_NAME,
+                version: SERVER_VERSION,
+                network: SERVER_NETWORK
+            }
+        });
+        // The review origin is a single-port singleton: the newest instance takes
+        // the fixed port over from a previous instance of our own review server so
+        // the most recently started client owns the one wallet-autoconnect origin.
+        const reviewServer = await startReviewServerWithTakeover((port) => reviewServerFactory.start(port), config.reviewPort, {
+            probeIdentity: (probePort) => probeReviewServerIdentity(probePort, config.reviewHost),
+            terminate: terminateProcessByPid,
+            delay: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+            currentPid: process.pid,
+            serviceName: SERVER_NAME,
+            logger
+        });
+        reviewServerForCleanup = reviewServer;
+        logger.info("review server started", {
+            host: reviewServer.host,
+            port: reviewServer.port
+        });
+        let shuttingDown = false;
+        const shutdown = async (signal) => {
+            logger.info("shutdown requested", { signal });
+            try {
+                const closeResults = await Promise.allSettled([
+                    ...(mcp ? [mcp.close()] : []),
+                    reviewServer.close()
+                ]);
+                for (const result of closeResults) {
+                    if (result.status === "rejected") {
+                        logger.error("shutdown close failed", {
+                            error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                logger.error("shutdown failed", {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+            finally {
+                try {
+                    store.close();
+                }
+                catch (error) {
+                    logger.error("activity store close failed", {
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            process.exit(exitCodeForSignal(signal));
+        };
+        const handleSignal = (signal) => {
+            if (shuttingDown) {
+                process.exit(exitCodeForSignal(signal));
+            }
+            shuttingDown = true;
+            void shutdown(signal).catch((error) => {
+                logger.error("shutdown failed", {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                process.exit(exitCodeForSignal(signal));
+            });
+        };
+        process.on("SIGINT", () => handleSignal("SIGINT"));
+        process.on("SIGTERM", () => handleSignal("SIGTERM"));
+        mcp = createMcpServer({
+            promptSurfaces: ADAPTER_PROMPT_SURFACES,
+            sessions,
+            activityStore: store,
+            reviewBaseUrl: `http://${reviewServer.host}:${reviewServer.port}`,
+            readService,
+            transactionActivityService: new TransactionActivityService({
+                activityStore: store,
+                source: new GraphqlSuiTransactionActivitySource({
+                    url: config.graphqlUrl,
+                    expectedChainIdentifier: config.expectedChainIdentifier
+                })
+            }),
+            localSettings,
+            logger
+        });
+        await startMcp(mcp, new StdioServerTransport());
+    }
+    catch (error) {
+        const closeResults = await Promise.allSettled([
+            ...(mcp ? [mcp.close()] : []),
+            ...(reviewServerForCleanup ? [reviewServerForCleanup.close()] : [])
+        ]);
+        for (const result of closeResults) {
+            if (result.status === "rejected") {
+                logger.error("startup cleanup close failed", {
+                    error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+                });
+            }
+        }
+        try {
+            activityStore?.close();
+        }
+        catch (error) {
+            logger.error("activity store close failed", {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+        throw error;
+    }
+}
+main().catch((error) => {
+    const logger = createStderrLogger("runtime");
+    logger.error("fatal runtime error", fatalErrorMeta(error));
+    process.exit(1);
+});
+function exitCodeForSignal(signal) {
+    return signal === "SIGINT" ? 130 : 143;
+}
+function fatalErrorMeta(error) {
+    if (error instanceof SuiEndpointError) {
+        return {
+            error: error.message,
+            kind: error.kind,
+            details: error.details
+        };
+    }
+    return {
+        error: error instanceof Error ? error.message : String(error)
+    };
+}