@stratabook/mcp 0.2.17 → 0.2.18

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to the Strata SDKs (`@stratabook/sdk`, `@stratabook/mcp`,
 and the `strata-sdk` Rust crate) are recorded here. Versions move together.
 
+## 0.2.18
+
+- Hot-reload locally paired session credentials inside a running MCP process;
+  `connect`, session replacement, and disconnect no longer require a client
+  restart.
+- Expose `strata_order_execute` in simple mode with human limit-order intent:
+  market label, side, percentage of available balance, and signed mark offset.
+  Strata resolves exact asset atoms, decimals, mark and tick alignment.
+- Keep authenticated order channels warm for durable dead-man heartbeats. A
+  placement whose guard cannot be proven is cancelled fail-closed.
+- Expand `strata_autonomy` into a public-key-only runtime handshake covering
+  package version, mode, credential source, loaded/file/on-chain session
+  consistency, execution readiness, expiry, and clock skew.
+- Preserve exact `retry_after_ms` values instead of retrying every transient
+  read after a fixed 150ms.
+
 ## 0.2.17
 
 - Consume the matching strategy-timed TypeScript SDK and allow an optional

package/README.md

@@ -62,9 +62,11 @@ returns to the live Control Center. Run the same command again to replace the
 old key atomically; the old key is revoked in the same signed transaction.
 
 There is no secret to paste into chat, no environment-variable screen, and no
-client config to edit after the read-only server is installed. Restart or
-refresh the MCP client after the browser confirms connection. Revoke the exact
-session and delete its local credential with:
+client config to edit after the read-only server is installed. A running MCP
+process detects the new, replaced, or removed local credential automatically;
+no client restart is required for credential changes. A package-version upgrade
+still requires the MCP host to launch the new process. Revoke the exact session
+and delete its local credential with:
 
 ```sh
 npx -y @stratabook/mcp disconnect
@@ -106,8 +108,9 @@ The compact default exposes the tools ordinary users need:
 - `strata_quote` — accepts `0.1 SOL`, `20 USDC`, or `$20`; token atoms remain optional
 - `strata_portfolio` and `strata_market_making_status`
 - `strata_trade` — returns a live quote when trading is not connected, with one setup link; follows the user's session limits when connected
+- `strata_order_execute` — understands instructions such as “sell 10% of available SOL at 3% above mark”; resolves exact atoms and tick rounding, submits through a warm order channel, and maintains fail-closed dead-man protection
 - `strata_market_making_prepare` and `strata_market_making_submit_and_wait`
-- `strata_autonomy` — reports whether optional trading is connected and the user's limits
+- `strata_autonomy` — reports the user's limits plus MCP version/mode, loaded and on-chain session consistency, execution readiness, expiry, and clock skew
 
 Advanced mode additionally exposes the complete protocol surface, including:
 

package/dist/src/autonomy.d.ts

@@ -42,6 +42,15 @@ export interface SessionAutonomy {
     readonly config: AutonomyConfig;
     readonly dailyBudget: DailyUsdBudget;
 }
+export type SessionAutonomyProvider = () => Promise<SessionAutonomy | null>;
+/**
+ * Build a live session source for long-running MCP hosts. The credential file
+ * may be replaced by `strata-mcp connect` while the stdio process remains
+ * alive, so callers must not close over the first environment snapshot. Daily
+ * spend remains process-local and survives policy/file refreshes for the same
+ * owner + session pair.
+ */
+export declare function liveSessionAutonomyProvider(loadEnvironment: () => Promise<Record<string, string | undefined>>): SessionAutonomyProvider;
 /** Parse the autonomy slider from a plain env bag; defaults to the calm `ask`. */
 export declare function parseAutonomyConfig(env: Record<string, string | undefined>): AutonomyConfig;
 /** Build the session-autonomy context from env, or null when no session key is set. */

package/dist/src/autonomy.js

@@ -26,6 +26,44 @@
  */
 import { StrataContractError, sessionSignerFromSecretKey, } from "@stratabook/sdk";
 export const AUTONOMY_LEVELS = ["ask", "limits", "instant"];
+/**
+ * Build a live session source for long-running MCP hosts. The credential file
+ * may be replaced by `strata-mcp connect` while the stdio process remains
+ * alive, so callers must not close over the first environment snapshot. Daily
+ * spend remains process-local and survives policy/file refreshes for the same
+ * owner + session pair.
+ */
+export function liveSessionAutonomyProvider(loadEnvironment) {
+    let fingerprint = null;
+    let current = null;
+    const budgets = new Map();
+    return async () => {
+        const env = await loadEnvironment();
+        const nextFingerprint = [
+            env.STRATA_OWNER_WALLET ?? "",
+            env.STRATA_SESSION_PUBLIC_KEY ?? "",
+            env.STRATA_SESSION_SECRET_KEY ?? "",
+            env.STRATA_AUTONOMY ?? "",
+            env.STRATA_AUTONOMY_MAX_USD_PER_TRADE ?? "",
+            env.STRATA_AUTONOMY_MAX_USD_PER_DAY ?? "",
+            env.STRATA_AUTONOMY_MARKETS ?? "",
+        ].join("\0");
+        if (fingerprint === nextFingerprint)
+            return current;
+        const parsed = await sessionAutonomyFromEnv(env);
+        if (parsed === null) {
+            fingerprint = nextFingerprint;
+            current = null;
+            return null;
+        }
+        const budgetKey = `${parsed.ownerWallet}:${parsed.signer.publicKey}`;
+        const dailyBudget = budgets.get(budgetKey) ?? parsed.dailyBudget;
+        budgets.set(budgetKey, dailyBudget);
+        current = { ...parsed, dailyBudget };
+        fingerprint = nextFingerprint;
+        return current;
+    };
+}
 function positiveNumber(raw) {
     if (raw === undefined)
         return undefined;

package/dist/src/cli.js

@@ -4,11 +4,11 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { DEFAULT_API_BASE, StrataApiError, StrataClient } from "@stratabook/sdk";
 import { STRATA_ACTION_GRAPH, STRATA_AGENT_HARNESS, } from "./generated-harness.js";
-import { createStrataMcpServer, probeStrataMcpReadiness } from "./server.js";
-import { sessionAutonomyFromEnv } from "./autonomy.js";
+import { createStrataMcpServer, probeStrataMcpReadiness, } from "./server.js";
+import { liveSessionAutonomyProvider, } from "./autonomy.js";
 import { SERVER_VERSION } from "./version.js";
 import { friendlyApiError, humanQuoteAmount, parseToolMode } from "./usability.js";
-import { DEFAULT_PAIRING_WEB_BASE, loadTradingEnvironment, runLocalPairing, tradingCredentialsPath, } from "./pairing.js";
+import { DEFAULT_PAIRING_WEB_BASE, loadTradingEnvironment, readTradingConnection, runLocalPairing, tradingCredentialsPath, } from "./pairing.js";
 function parse(argv) {
     const knownCommands = new Set(["doctor", "connect", "disconnect"]);
     const first = argv[0];
@@ -233,13 +233,33 @@ async function main() {
         });
         return;
     }
-    const sessionEnv = await loadTradingEnvironment(process.env);
+    const runtimeEnvironment = options.credentialsFile === undefined
+        ? { ...process.env }
+        : { ...process.env, STRATA_MCP_CREDENTIALS_FILE: options.credentialsFile };
+    const sessionEnv = await loadTradingEnvironment(runtimeEnvironment);
     if (options.command === "doctor") {
         await runDoctor(options, sessionEnv);
         return;
     }
-    const sessionAutonomy = await sessionAutonomyFromEnv(sessionEnv);
-    const withSession = sessionAutonomy ? { ...options, sessionAutonomy } : options;
+    const sessionAutonomyProvider = liveSessionAutonomyProvider(() => loadTradingEnvironment(runtimeEnvironment));
+    const sessionAutonomy = await sessionAutonomyProvider();
+    const sessionCredentialDiagnostics = async () => {
+        const path = tradingCredentialsPath(runtimeEnvironment);
+        const stored = await readTradingConnection(path);
+        const explicit = Boolean(runtimeEnvironment.STRATA_SESSION_SECRET_KEY || runtimeEnvironment.STRATA_OWNER_WALLET);
+        return {
+            source: explicit ? "environment" : stored === null ? "none" : "file",
+            credentials_file: path,
+            credential_file_session_public_key: stored?.session_public_key ?? null,
+        };
+    };
+    const withSession = {
+        ...options,
+        sessionAutonomyProvider,
+        sessionCredentialDiagnostics,
+        persistentOrderGuards: options.transport === "stdio",
+        ...(sessionAutonomy === null ? {} : { sessionAutonomy }),
+    };
     if (sessionAutonomy) {
         process.stderr.write(`[strata-mcp] session autonomy: ${sessionAutonomy.config.level} `
             + `(wallet ${sessionAutonomy.ownerWallet.slice(0, 6)}…, session ${sessionAutonomy.signer.publicKey.slice(0, 6)}…, `

package/dist/src/pairing.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { chmod, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { createServer } from "node:http";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
@@ -70,13 +70,23 @@ export async function readTradingConnection(path = tradingCredentialsPath()) {
 }
 export async function writeTradingConnection(connection, path = tradingCredentialsPath()) {
     await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-    await writeFile(path, `${JSON.stringify(connection, null, 2)}\n`, {
-        encoding: "utf8",
-        mode: 0o600,
-    });
-    // `mode` is honored on creation. chmod also tightens a pre-existing file.
-    if (process.platform !== "win32")
-        await chmod(path, 0o600);
+    const temporary = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    try {
+        await writeFile(temporary, `${JSON.stringify(connection, null, 2)}\n`, {
+            encoding: "utf8",
+            mode: 0o600,
+        });
+        // `mode` is honored on creation. chmod also protects unusual umasks.
+        if (process.platform !== "win32")
+            await chmod(temporary, 0o600);
+        // Same-directory rename means the live MCP sees either the old complete
+        // credential or the new complete credential, never a partially written file.
+        await rename(temporary, path);
+    }
+    catch (error) {
+        await unlink(temporary).catch(() => undefined);
+        throw error;
+    }
 }
 export async function removeTradingConnection(path = tradingCredentialsPath()) {
     try {
@@ -309,6 +319,6 @@ export async function runLocalPairing(options) {
     process.stdout.write("Waiting for the owner-wallet signature…\n");
     const ownerWallet = await callback.completion;
     process.stdout.write(options.action === "connect"
-        ? `✓ Trading connected for ${ownerWallet}. Credentials saved privately at ${path}.\nRestart or refresh your MCP client.\n`
+        ? `✓ Trading connected for ${ownerWallet}. Credentials saved privately at ${path}.\nThis MCP release and newer pick it up automatically; restart only older clients.\n`
         : `✓ Session revoked for ${ownerWallet}. Local trading credentials removed.\n`);
 }

package/dist/src/server.d.ts

@@ -1,6 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StrataClient, StrataPlatformClient, type CapabilityCatalog } from "@stratabook/sdk";
-import { type SessionAutonomy } from "./autonomy.js";
+import { type SessionAutonomy, type SessionAutonomyProvider } from "./autonomy.js";
 import { type StrataMcpToolMode } from "./usability.js";
 export interface StrataMcpOptions {
     apiBase?: string;
@@ -15,6 +15,21 @@ export interface StrataMcpOptions {
      * every trade is prepared for a human to sign. Built from env in the CLI.
      */
     sessionAutonomy?: SessionAutonomy;
+    /**
+     * Live source used by long-running hosts. When present it is consulted for
+     * every trading call, allowing `strata-mcp connect` to rotate the private
+     * credential file without restarting the MCP process.
+     */
+    sessionAutonomyProvider?: SessionAutonomyProvider;
+    /** Public-only credential metadata for the runtime health handshake. */
+    sessionCredentialDiagnostics?: () => Promise<SessionCredentialDiagnostics>;
+    /** False for stateless HTTP runtimes that cannot heartbeat a durable guard. */
+    persistentOrderGuards?: boolean;
+}
+export interface SessionCredentialDiagnostics {
+    readonly source: "environment" | "file" | "none";
+    readonly credentials_file: string | null;
+    readonly credential_file_session_public_key: string | null;
 }
 export interface StrataMcpRuntime {
     server: McpServer;

package/dist/src/server.js

@@ -369,6 +369,315 @@ function orderOperationFromArgs(args) {
 }
 const PLATFORM_MARKET_PAGE_LIMIT = 100;
 const PLATFORM_MARKET_MAX_PAGES = 20;
+/**
+ * Keeps authenticated order channels warm so a durable dead-man ticket can be
+ * heartbeated after the one MCP call returns. A session rotation closes every
+ * old channel; its already-armed ticket then fails closed instead of leaving
+ * orders unmanaged.
+ */
+class WarmOrderConnectionPool {
+    platformClient;
+    connections = new Map();
+    sessionBinding = null;
+    constructor(platformClient) {
+        this.platformClient = platformClient;
+    }
+    reconcile(autonomy) {
+        const binding = autonomy === null
+            ? null
+            : `${autonomy.ownerWallet}:${autonomy.signer.publicKey}`;
+        if (binding === this.sessionBinding)
+            return;
+        this.close();
+        this.sessionBinding = binding;
+    }
+    async get(marketId, autonomy) {
+        this.reconcile(autonomy);
+        let pending = this.connections.get(marketId);
+        if (!pending) {
+            pending = this.platformClient.orders.connect(marketId, autonomy.ownerWallet, autonomy.signer, {
+                onError: (error) => {
+                    process.stderr.write(`[strata-mcp] guarded order channel failed for ${marketId}: ${safeMessage(error)}\n`);
+                },
+            }).then(async (connection) => {
+                await connection.ready;
+                return connection;
+            });
+            this.connections.set(marketId, pending);
+            pending.catch(() => {
+                if (this.connections.get(marketId) === pending)
+                    this.connections.delete(marketId);
+            });
+        }
+        return pending;
+    }
+    close() {
+        for (const pending of this.connections.values()) {
+            pending.then((connection) => connection.close()).catch(() => undefined);
+        }
+        this.connections.clear();
+        this.sessionBinding = null;
+    }
+}
+/** Resolve a human limit-order instruction from one coherent public snapshot. */
+async function resolveFriendlyOrderIntent(platformClient, autonomy, args, nowMs) {
+    const percentageHundredths = Math.round(args.availablePercent * 100);
+    if (!Number.isFinite(args.availablePercent)
+        || args.availablePercent <= 0
+        || args.availablePercent > 100
+        || Math.abs(args.availablePercent * 100 - percentageHundredths) > 1e-8) {
+        throw new TypeError("availablePercent must be greater than 0 and at most 100, with at most two decimals");
+    }
+    if (!Number.isSafeInteger(args.markOffsetBps) || args.markOffsetBps <= -10_000) {
+        throw new TypeError("markOffsetBps must be an integer greater than -10000");
+    }
+    const market = await platformClient.markets.resolve(args.market);
+    if (market.status !== "active" || !market.available_actions.includes("place_order")) {
+        throw new Error(`${market.label} is not currently accepting resting orders`);
+    }
+    const [mark, status, fees, portfolio, assetsPage] = await Promise.all([
+        platformClient.marketData.mark(market.market_id),
+        platformClient.books.status(market.market_id),
+        platformClient.books.fees(market.market_id),
+        platformClient.account.portfolio(autonomy.ownerWallet),
+        platformClient.assets.list({ limit: 200 }),
+    ]);
+    if (mark.stale || mark.price_atoms_per_base_unit === null) {
+        throw new Error(`${market.label} does not have a fresh mark`);
+    }
+    const baseAsset = assetsPage.assets.find((asset) => asset.asset_id === market.base_asset_id)
+        ?? await platformClient.assets.resolve(market.base_asset_id);
+    const quoteAsset = assetsPage.assets.find((asset) => asset.asset_id === market.quote_asset_id)
+        ?? await platformClient.assets.resolve(market.quote_asset_id);
+    if (mark.quote_decimals !== quoteAsset.decimals) {
+        throw new Error(`${market.label} mark decimals do not match its quote asset`);
+    }
+    const tick = BigInt(status.tick_size_atoms);
+    const markAtoms = BigInt(mark.price_atoms_per_base_unit);
+    if (tick <= 0n || markAtoms <= 0n)
+        throw new Error(`${market.label} returned invalid price metadata`);
+    const factor = BigInt(10_000 + args.markOffsetBps);
+    const priceDenominator = 10000n * tick;
+    const priceNumerator = markAtoms * factor;
+    const priceTicks = args.side === "sell"
+        ? (priceNumerator + priceDenominator - 1n) / priceDenominator
+        : priceNumerator / priceDenominator;
+    const limitPriceAtoms = priceTicks * tick;
+    if (limitPriceAtoms <= 0n)
+        throw new Error("the resolved limit price is below one tick");
+    const inputAssetId = args.side === "sell" ? market.base_asset_id : market.quote_asset_id;
+    const inputBalance = portfolio.balances.find((balance) => balance.asset_id === inputAssetId);
+    if (!inputBalance)
+        throw new Error(`no ${args.side === "sell" ? baseAsset.symbol : quoteAsset.symbol} balance is available`);
+    const availableAtoms = BigInt(inputBalance.available_atoms);
+    const budgetAtoms = availableAtoms * BigInt(percentageHundredths) / 10000n;
+    const baseUnit = 10n ** BigInt(baseAsset.decimals);
+    const positiveMakerFeeBps = BigInt(Math.max(0, fees.passive_maker_fee_bps));
+    const sizeAtoms = args.side === "sell"
+        ? budgetAtoms
+        : budgetAtoms * baseUnit * 10000n
+            / (limitPriceAtoms * (10000n + positiveMakerFeeBps));
+    if (sizeAtoms <= 0n)
+        throw new Error("the requested percentage resolves below the minimum order size");
+    if (sizeAtoms < BigInt(status.minimum_order_size_atoms)) {
+        throw new Error(`the resolved size is below ${status.minimum_order_size_atoms} base atoms`);
+    }
+    // Autonomy ceilings are risk limits, so value the order at the less
+    // favourable of its live mark and limit instead of allowing an aggressive
+    // offset to understate the amount the session may spend.
+    const riskPriceAtoms = markAtoms > limitPriceAtoms ? markAtoms : limitPriceAtoms;
+    const notionalQuoteAtoms = sizeAtoms * riskPriceAtoms / baseUnit;
+    const notionalUsd = Number(notionalQuoteAtoms) / 10 ** quoteAsset.decimals;
+    if (!Number.isFinite(notionalUsd) || notionalUsd <= 0) {
+        throw new Error("the resolved order notional is invalid");
+    }
+    const clientOrderId = args.clientOrderId
+        ?? `mcp-${nowMs().toString(36)}-${autonomy.signer.publicKey.slice(0, 8)}`;
+    return {
+        marketId: market.market_id,
+        clientOrderId,
+        side: args.side,
+        orderType: args.orderType ?? "post_only",
+        limitPriceAtoms: limitPriceAtoms.toString(),
+        sizeAtoms: sizeAtoms.toString(),
+        notionalUsd,
+        resolution: {
+            market: market.label,
+            market_id: market.market_id,
+            client_order_id: clientOrderId,
+            side: args.side,
+            available_percent: args.availablePercent,
+            input_asset: args.side === "sell" ? baseAsset.symbol : quoteAsset.symbol,
+            input_available_atoms: availableAtoms.toString(),
+            input_budget_atoms: budgetAtoms.toString(),
+            size_atoms: sizeAtoms.toString(),
+            size_display: `${formatAtoms(sizeAtoms.toString(), baseAsset.decimals)} ${baseAsset.symbol}`,
+            mark_price_atoms: markAtoms.toString(),
+            mark_offset_bps: args.markOffsetBps,
+            limit_price_atoms: limitPriceAtoms.toString(),
+            risk_price_atoms: riskPriceAtoms.toString(),
+            risk_notional_usd: notionalUsd,
+            tick_size_atoms: tick.toString(),
+            portfolio_observed_slot: portfolio.observed_slot,
+            portfolio_observed_at_ms: portfolio.observed_at_ms,
+            mark_server_time_ms: mark.server_time_ms,
+        },
+    };
+}
+async function waitForOrderSubmission(connection, orderControlId, idempotencyKey) {
+    let status = await connection.status(orderControlId, idempotencyKey);
+    for (let attempt = 0; status.status === "submitting" && attempt < 12; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        status = await connection.status(orderControlId, idempotencyKey);
+    }
+    return status;
+}
+/**
+ * Existing protocol cannot pre-sign a cancel for an order that does not exist
+ * yet. Close that gap operationally: confirm the placement, arm immediately on
+ * the same warm socket, and cancel the new order if arming cannot be proven.
+ */
+async function executeGuardedOrder(connection, autonomy, operation, idempotencyKey, deadManTimeoutMs) {
+    const receipt = await connection.execute({ operation, idempotencyKey });
+    let status = null;
+    let statusError = null;
+    try {
+        status = await waitForOrderSubmission(connection, receipt.order_control_id, idempotencyKey);
+    }
+    catch (error) {
+        // The order may already be live. Continue to the guard instead of leaving
+        // it unmanaged merely because the confirmation read was throttled.
+        statusError = safeMessage(error);
+    }
+    if (status?.status === "failed") {
+        return {
+            ok: false,
+            code: "order_submission_failed",
+            message: `Order submission failed: ${status.failure_code ?? "unknown"}.`,
+            details: { receipt, status },
+        };
+    }
+    let guardError;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            const deadMan = await connection.armDeadMan({
+                timeoutMs: deadManTimeoutMs,
+                idempotencyKey: `guard-${receipt.order_control_id}`,
+            });
+            return { ok: true, receipt, status, statusError, deadMan };
+        }
+        catch (error) {
+            guardError = error;
+            if (attempt === 0) {
+                const delay = error instanceof StrataApiError ? error.retryAfterMs ?? 100 : 100;
+                // No guard exists yet. A long provider retry window must not leave the
+                // freshly placed order exposed while we wait; cancel it immediately.
+                if (delay > 250)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+    const orderId = receipt.order_ids[0];
+    if (orderId) {
+        try {
+            const cancellation = await connection.execute({
+                operation: { action: "cancel", ownerWallet: autonomy.ownerWallet, orderId },
+                idempotencyKey: `guard-failed-cancel-${receipt.order_control_id}`,
+            });
+            let cancellationStatus;
+            try {
+                cancellationStatus = await waitForOrderSubmission(connection, cancellation.order_control_id, `guard-failed-cancel-${receipt.order_control_id}`);
+            }
+            catch (cancelStatusError) {
+                return {
+                    ok: false,
+                    code: "dead_man_setup_ambiguous",
+                    message: "The order guard failed and Strata submitted a cancellation, but could not prove that cancellation completed.",
+                    details: {
+                        receipt,
+                        status,
+                        status_error: statusError,
+                        cancellation,
+                        guard_error: safeMessage(guardError),
+                        cancellation_status_error: safeMessage(cancelStatusError),
+                    },
+                };
+            }
+            if (cancellationStatus.status !== "submitted") {
+                return {
+                    ok: false,
+                    code: "dead_man_setup_ambiguous",
+                    message: "The order guard failed and its fail-closed cancellation was not confirmed.",
+                    details: { receipt, status, status_error: statusError, cancellation, cancellationStatus },
+                };
+            }
+            return {
+                ok: false,
+                code: "dead_man_setup_failed",
+                message: "The order was submitted but its dead-man guard could not be proven, so Strata cancelled it fail-closed.",
+                details: {
+                    receipt,
+                    status,
+                    status_error: statusError,
+                    cancellation,
+                    cancellation_status: cancellationStatus,
+                    guard_error: safeMessage(guardError),
+                },
+            };
+        }
+        catch (cancelError) {
+            return {
+                ok: false,
+                code: "dead_man_setup_ambiguous",
+                message: "The order was submitted, but neither its dead-man guard nor fail-closed cancellation could be proven.",
+                details: {
+                    receipt,
+                    status,
+                    status_error: statusError,
+                    guard_error: safeMessage(guardError),
+                    cancellation_error: safeMessage(cancelError),
+                },
+            };
+        }
+    }
+    return {
+        ok: false,
+        code: "dead_man_setup_ambiguous",
+        message: "The order was submitted without a returned order ID, so its guard could not be proven.",
+        details: { receipt, status, status_error: statusError, guard_error: safeMessage(guardError) },
+    };
+}
+async function observePlacedOrderLifecycle(platformClient, ownerWallet, orderIds) {
+    try {
+        const portfolio = await platformClient.account.portfolio(ownerWallet);
+        const orders = orderIds.map((orderId) => {
+            const visible = portfolio.open_orders.find((order) => order.order_id === orderId);
+            return { order_id: orderId, state: visible?.state ?? "pending_visibility" };
+        });
+        const state = orders.length > 0 && orders.every((order) => order.state === "open" || order.state === "partially_filled")
+            ? orders.every((order) => order.state === "open") ? "confirmed_open" : "partially_filled"
+            : "confirmed_pending_visibility";
+        return {
+            state,
+            orders,
+            observed_at_ms: portfolio.observed_at_ms,
+            observed_slot: portfolio.observed_slot,
+            unavailable_market_ids: portfolio.unavailable_market_ids,
+            error: null,
+        };
+    }
+    catch (error) {
+        return {
+            state: "confirmed_pending_visibility",
+            orders: orderIds.map((orderId) => ({ order_id: orderId, state: "pending_visibility" })),
+            observed_at_ms: null,
+            observed_slot: null,
+            unavailable_market_ids: [],
+            error: safeMessage(error),
+        };
+    }
+}
 /**
  * Every live platform market keyed by label, so the tool can hand agents the
  * opaque `market_id` (and asset ids) that every by-market tool takes. A
@@ -404,6 +713,8 @@ async function platformMarketIdentities(platformClient) {
 export async function createStrataMcpServer(options = {}) {
     const client = strataClient(options);
     const toolMode = options.toolMode ?? "simple";
+    const autonomyForCall = options.sessionAutonomyProvider
+        ?? (async () => options.sessionAutonomy ?? null);
     const platformClient = options.platformClient ?? new StrataPlatformClient({
         apiBase: options.apiBase,
         timeoutMs: options.timeoutMs,
@@ -1444,7 +1755,8 @@ export async function createStrataMcpServer(options = {}) {
             amountInAtoms: resolvedAtoms,
             maximumToleranceBps,
         }));
-        if (!options.sessionAutonomy) {
+        const autonomy = await autonomyForCall();
+        if (!autonomy) {
             return toolResult({
                 executed: false,
                 reason: "trading_not_connected",
@@ -1464,18 +1776,18 @@ export async function createStrataMcpServer(options = {}) {
             : null;
         const resolver = new MarketMetaResolver(platformClient, async () => sonarMarkets, () => Date.now());
         const marketId = sonar ? await resolver.idForLabel(sonar.label) : null;
-        const decision = decideAutonomy(options.sessionAutonomy, marketId ?? "", notional, Date.now());
+        const decision = decideAutonomy(autonomy, marketId ?? "", notional, Date.now());
         if (!decision.allow) {
             return toolResult({ executed: false, reason: decision.reason, quote: freshQuote }, `${decision.reason} The live quote is attached; no transaction was sent.`);
         }
         const receipt = await client.executeQuote({
             quote: freshQuote,
-            ownerWallet: options.sessionAutonomy.ownerWallet,
-            signer: options.sessionAutonomy.signer,
+            ownerWallet: autonomy.ownerWallet,
+            signer: autonomy.signer,
             ...(idempotencyKey === undefined ? {} : { idempotencyKey }),
         });
         if (notional !== null)
-            options.sessionAutonomy.dailyBudget.record(notional, Date.now());
+            autonomy.dailyBudget.record(notional, Date.now());
         return toolResult({ executed: true, receipt, notional_usd: notional }, `Executed ${side} ${inputDisplay} as ${receipt.signature}.`);
     }));
     registerTool("strata_swap_quote", {
@@ -2135,7 +2447,8 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, `Submitted IntentBook control as ${response.signature}.`);
     }));
-    registerAutonomyTools(registerTool, client, platformClient, options.sessionAutonomy, () => typeof Date !== "undefined" ? Date.now() : 0);
+    const orderConnections = new WarmOrderConnectionPool(platformClient);
+    registerAutonomyTools(registerTool, client, platformClient, autonomyForCall, orderConnections, toolMode, options.persistentOrderGuards ?? true, options.sessionCredentialDiagnostics, () => typeof Date !== "undefined" ? Date.now() : 0);
     void [
         markets,
         quote,
@@ -2161,10 +2474,12 @@ export async function createStrataMcpServer(options = {}) {
     const refresh = async () => {
         if (closed)
             return;
-        const [catalog, platformCatalog] = await Promise.all([
+        const [catalog, platformCatalog, autonomy] = await Promise.all([
             client.capabilities(),
             platformClient.discovery.read(),
+            autonomyForCall(),
         ]);
+        orderConnections.reconcile(autonomy);
         applyToolAvailability(registeredTools, catalog, platformCatalog, toolMode);
     };
     const timer = setInterval(() => {
@@ -2179,11 +2494,12 @@ export async function createStrataMcpServer(options = {}) {
         close: async () => {
             closed = true;
             clearInterval(timer);
+            orderConnections.close();
             await server.close();
         },
     };
 }
-function registerAutonomyTools(registerTool, client, platformClient, autonomy, nowMs) {
+function registerAutonomyTools(registerTool, client, platformClient, autonomyProvider, orderConnections, toolMode, persistentOrderGuards, credentialDiagnostics, nowMs) {
     // Always present, always read-only: the agent may show the slider and offer
     // to change it, but nothing it calls can raise its own autonomy.
     registerTool("strata_autonomy", {
@@ -2199,8 +2515,16 @@ function registerAutonomyTools(registerTool, client, platformClient, autonomy, n
             openWorldHint: false,
         },
     }, async () => {
+        let autonomy = null;
+        let runtimeError = null;
+        try {
+            autonomy = await autonomyProvider();
+        }
+        catch (error) {
+            runtimeError = safeMessage(error);
+        }
         const howToChange = {
-            setup: "Open the Agents page, connect the owner wallet, register once, then copy the MCP trading config into your client's local settings.",
+            setup: "Run `npx -y @stratabook/mcp connect`; it opens the Agents page, registers the locally generated public key, and the running MCP hot-loads the private credential.",
             agents_page: "https://stratabook.app/agents",
             generic_clients: "Claude Desktop, Cursor, Windsurf, Codex, or any local stdio MCP host",
             note: "Read-only tools need none of this. Only the user changes trading authority; an agent can never raise its own level.",
@@ -2212,12 +2536,61 @@ function registerAutonomyTools(registerTool, client, platformClient, autonomy, n
                 session_env: "STRATA_SESSION_SECRET_KEY + STRATA_OWNER_WALLET (register the key on the Agents page)",
             },
         };
+        let credential = {
+            source: "none",
+            credentials_file: null,
+            credential_file_session_public_key: null,
+        };
+        try {
+            credential = await credentialDiagnostics?.() ?? credential;
+        }
+        catch (error) {
+            runtimeError ??= safeMessage(error);
+        }
         if (!autonomy) {
-            return toolResult({ session_configured: false, level: "ask", how_to_change: howToChange }, "Read-only is ready. Trading is not connected, so I cannot send transactions. "
-                + "If you want trading, open https://stratabook.app/agents and copy its MCP trading config "
-                + "into your client; never paste the session secret into chat.");
+            return toolResult({
+                session_configured: false,
+                level: "ask",
+                runtime: {
+                    mcp_version: SERVER_VERSION,
+                    tool_mode: toolMode,
+                    credential_source: credential.source,
+                    credentials_file: credential.credentials_file,
+                    loaded_session_public_key: null,
+                    credential_file_session_public_key: credential.credential_file_session_public_key,
+                    session_key_consistent: null,
+                    on_chain: null,
+                    trading_tools_usable: false,
+                    diagnostic_error: runtimeError,
+                    credential_reload_supported: true,
+                    credential_restart_required: false,
+                    package_upgrade_requires_process_restart: true,
+                },
+                how_to_change: howToChange,
+            }, "Read-only is ready. Trading is not connected, so I cannot send transactions. "
+                + "If you want trading, run `npx -y @stratabook/mcp connect`; never paste the session secret into chat.");
         }
         const { config } = autonomy;
+        let onChain = null;
+        if (platformClient.vault?.status) {
+            try {
+                const status = await platformClient.vault.status({
+                    walletAddress: autonomy.ownerWallet,
+                    sessionPublicKey: autonomy.signer.publicKey,
+                });
+                onChain = {
+                    vault_state: status.state,
+                    session_public_key: status.session?.session_public_key ?? null,
+                    session_state: status.session?.state ?? "absent",
+                    market_execution_ready: status.session?.market_execution_ready ?? false,
+                    expires_at_ms: status.session?.expires_at_ms ?? null,
+                    clock_skew_ms: status.server_time_ms - nowMs(),
+                };
+            }
+            catch (error) {
+                runtimeError ??= safeMessage(error);
+            }
+        }
         const spentToday = autonomy.dailyBudget.spentToday(nowMs());
         const state = {
             session_configured: true,
@@ -2231,6 +2604,30 @@ function registerAutonomyTools(registerTool, client, platformClient, autonomy, n
                 ? null
                 : Number(Math.max(0, config.maxUsdPerDay - spentToday).toFixed(2)),
             allowed_market_ids: config.allowedMarketIds ?? null,
+            runtime: {
+                mcp_version: SERVER_VERSION,
+                tool_mode: toolMode,
+                credential_source: credential.source,
+                credentials_file: credential.credentials_file,
+                loaded_session_public_key: autonomy.signer.publicKey,
+                credential_file_session_public_key: credential.credential_file_session_public_key,
+                session_key_consistent: credential.source === "file"
+                    ? credential.credential_file_session_public_key === autonomy.signer.publicKey
+                    : credential.source === "environment"
+                        ? true
+                        : null,
+                on_chain: onChain,
+                trading_tools_usable: onChain === null
+                    ? null
+                    : onChain.vault_state === "active"
+                        && onChain.session_state === "active"
+                        && onChain.market_execution_ready === true
+                        && onChain.session_public_key === autonomy.signer.publicKey,
+                diagnostic_error: runtimeError,
+                credential_reload_supported: true,
+                credential_restart_required: false,
+                package_upgrade_requires_process_restart: true,
+            },
             how_to_change: howToChange,
         };
         const summary = config.level === "instant"
@@ -2241,8 +2638,6 @@ function registerAutonomyTools(registerTool, client, platformClient, autonomy, n
                 : "Autonomy: ask — I prepare trades but never sign them; you sign each one.";
         return toolResult(state, summary);
     });
-    if (!autonomy)
-        return;
     const resolver = new MarketMetaResolver(platformClient, async () => (await client.markets()).markets, nowMs);
     const markFor = async (marketId) => {
         const mark = await platformClient.marketData.mark(marketId);
@@ -2253,6 +2648,7 @@ function registerAutonomyTools(registerTool, client, platformClient, autonomy, n
         };
     };
     const refuse = (reason, prepared, summary) => toolResult({ executed: false, reason, prepared }, summary);
+    const tradingNotConnected = () => toolError("trading_not_connected", "Trading is not connected. Run strata-mcp connect; this running MCP will pick up the private credential automatically.", false);
     // ── one-shot existing IntentBook seat control ──────────────────────────────
     registerTool("strata_market_making_intent_execute", {
         title: "Execute Strata IntentBook control",
@@ -2274,6 +2670,9 @@ function registerAutonomyTools(registerTool, client, platformClient, autonomy, n
             openWorldHint: true,
         },
     }, async (args) => guardedTool(client, "mm.intent.manage", async () => {
+        const autonomy = await autonomyProvider();
+        if (!autonomy)
+            return tradingNotConnected();
         let operation;
         if (args.action === "revoke") {
             operation = { action: "revoke", ownerWallet: autonomy.ownerWallet };
@@ -2332,6 +2731,9 @@ function registerAutonomyTools(registerTool, client, platformClient, autonomy, n
             openWorldHint: true,
         },
     }, async (args) => guardedTool(client, "trade.submit", async () => {
+        const autonomy = await autonomyProvider();
+        if (!autonomy)
+            return tradingNotConnected();
         const quote = await retryReadOnce(() => client.quote({
             market: args.market,
             side: args.side,
@@ -2360,17 +2762,27 @@ function registerAutonomyTools(registerTool, client, platformClient, autonomy, n
     // ── one-shot order control (place / cancel / replace / batch) ─────────────
     registerTool("strata_order_execute", {
         title: "Execute a Strata order control",
-        description: "Place, cancel, replace, or batch orders and, within the autonomy slider, sign with the session "
-            + "key and submit in one call. Owner wallet and session key come from the configured session. "
-            + "Under \"ask\" (or over a \"limits\" ceiling) it prepares the transaction and asks you to sign.",
+        description: "Place a human limit order such as 'sell 10% of available SOL at mark +3%' in one call, or use "
+            + "the exact-atom cancel/replace/batch controls. Strata resolves the balance, market, mark, decimals "
+            + "and tick grid internally. Autonomous placements keep a warm dead-man guard; if it cannot be "
+            + "established, the new order is cancelled fail-closed.",
         inputSchema: {
-            marketId: z.string().regex(/^market_[0-9a-f]{32}$/),
+            market: z.string().min(1).max(128).optional()
+                .describe("Friendly market label such as SOL/USDC (also accepts a market ID)."),
+            marketId: z.string().regex(/^market_[0-9a-f]{32}$/).optional()
+                .describe("Advanced alternative to market."),
             action: z.enum(["place", "cancel", "cancel_all", "replace", "batch"]),
             clientOrderId: z.string().min(1).max(64).regex(/^[A-Za-z0-9._-]+$/).optional(),
             side: z.enum(["buy", "sell"]).optional(),
             orderType: z.enum(["good_until_cancelled", "post_only"]).optional(),
             limitPriceAtoms: z.string().regex(/^[1-9][0-9]*$/).max(20).optional(),
             sizeAtoms: z.string().regex(/^[1-9][0-9]*$/).max(20).optional(),
+            availablePercent: z.number().positive().max(100).optional()
+                .describe("Friendly placement size: percentage of available input balance, for example 10."),
+            markOffsetBps: z.number().int().min(-9_999).max(100_000).optional()
+                .describe("Signed offset from the current mark in basis points; +300 is 3% above mark."),
+            deadManTimeoutMs: z.number().int().min(1_000).max(30_000).optional()
+                .describe("Guard timeout for an autonomous placement; friendly orders default to 10000ms."),
             orderId: z.string().regex(/^order_[0-9a-f]{32}$/).optional(),
             operations: z.array(z.object({
                 action: z.enum(["place", "cancel", "replace"]),
@@ -2390,34 +2802,136 @@ function registerAutonomyTools(registerTool, client, platformClient, autonomy, n
             openWorldHint: true,
         },
     }, async (args) => guardedTool(client, "orders.submit", async () => {
+        const autonomy = await autonomyProvider();
+        if (!autonomy)
+            return tradingNotConnected();
+        const friendly = args.availablePercent !== undefined || args.markOffsetBps !== undefined;
+        let resolved = null;
+        let marketId = args.marketId;
+        let clientOrderId = args.clientOrderId;
+        let side = args.side;
+        let orderType = args.orderType;
+        let limitPriceAtoms = args.limitPriceAtoms;
+        let sizeAtoms = args.sizeAtoms;
+        if (friendly) {
+            if (args.action !== "place"
+                || args.market === undefined
+                || args.side === undefined
+                || args.availablePercent === undefined
+                || args.limitPriceAtoms !== undefined
+                || args.sizeAtoms !== undefined
+                || args.marketId !== undefined) {
+                return toolError("invalid_order_intent", "Friendly placement requires action=place, market, side and availablePercent; omit marketId, limitPriceAtoms and sizeAtoms.", false);
+            }
+            try {
+                resolved = await resolveFriendlyOrderIntent(platformClient, autonomy, {
+                    market: args.market,
+                    side: args.side,
+                    availablePercent: args.availablePercent,
+                    markOffsetBps: args.markOffsetBps ?? 0,
+                    ...(args.clientOrderId === undefined ? {} : { clientOrderId: args.clientOrderId }),
+                    ...(args.orderType === undefined ? {} : { orderType: args.orderType }),
+                }, nowMs);
+            }
+            catch (error) {
+                if (error instanceof StrataApiError)
+                    throw error;
+                return toolError("order_intent_unavailable", safeMessage(error), true);
+            }
+            marketId = resolved.marketId;
+            clientOrderId = resolved.clientOrderId;
+            side = resolved.side;
+            orderType = resolved.orderType;
+            limitPriceAtoms = resolved.limitPriceAtoms;
+            sizeAtoms = resolved.sizeAtoms;
+        }
+        else if (marketId === undefined && args.market !== undefined) {
+            try {
+                marketId = (await platformClient.markets.resolve(args.market)).market_id;
+            }
+            catch (error) {
+                if (error instanceof StrataApiError)
+                    throw error;
+                return toolError("market_unavailable", safeMessage(error), true);
+            }
+        }
+        if (marketId === undefined) {
+            return toolError("invalid_request", "Give market or marketId.", false);
+        }
         const challenge = orderOperationFromArgs({
-            ...args,
+            action: args.action,
+            ...(clientOrderId === undefined ? {} : { clientOrderId }),
+            ...(side === undefined ? {} : { side }),
+            ...(orderType === undefined ? {} : { orderType }),
+            ...(limitPriceAtoms === undefined ? {} : { limitPriceAtoms }),
+            ...(sizeAtoms === undefined ? {} : { sizeAtoms }),
+            ...(args.orderId === undefined ? {} : { orderId: args.orderId }),
+            ...(args.operations === undefined ? {} : { operations: args.operations }),
             ownerWallet: autonomy.ownerWallet,
             sessionPublicKey: autonomy.signer.publicKey,
         });
         if ("content" in challenge)
             return challenge;
         // A place/replace risks new base; a cancel reduces it (notional 0).
-        const baseAtoms = (args.action === "place" || args.action === "replace") && args.sizeAtoms !== undefined
-            ? BigInt(args.sizeAtoms)
+        const baseAtoms = (args.action === "place" || args.action === "replace") && sizeAtoms !== undefined
+            ? BigInt(sizeAtoms)
             : 0n;
-        const notional = await estimateBaseNotionalUsd(resolver, markFor, args.marketId, baseAtoms);
-        const decision = decideAutonomy(autonomy, args.marketId, notional, nowMs());
+        const notional = resolved?.notionalUsd
+            ?? await estimateBaseNotionalUsd(resolver, markFor, marketId, baseAtoms);
+        const decision = decideAutonomy(autonomy, marketId, notional, nowMs());
         if (!decision.allow) {
-            const prepared = await platformClient.orders.prepare(args.marketId, {
+            const prepared = await platformClient.orders.prepare(marketId, {
                 operation: challenge,
             });
-            return refuse(decision.reason, prepared, decision.reason);
+            return toolResult({
+                executed: false,
+                reason: decision.reason,
+                prepared,
+                ...(resolved === null ? {} : { resolved_intent: resolved.resolution }),
+            }, decision.reason);
         }
         const { sessionPublicKey: _session, ...operation } = challenge;
-        const receipt = await platformClient.orders.execute(args.marketId, {
+        const idempotencyKey = args.idempotencyKey ?? clientOrderId ?? `mcp-${nowMs().toString(36)}`;
+        if (args.action === "place" && (friendly || args.deadManTimeoutMs !== undefined)) {
+            if (!persistentOrderGuards) {
+                return toolError("persistent_guard_unavailable", "Autonomous resting orders require a persistent stdio MCP runtime so dead-man heartbeats continue after this call.", false);
+            }
+            const connection = await orderConnections.get(marketId, autonomy);
+            const guarded = await executeGuardedOrder(connection, autonomy, operation, idempotencyKey, args.deadManTimeoutMs ?? 10_000);
+            if (!guarded.ok) {
+                return toolError(guarded.code, guarded.message, true, undefined, guarded.details);
+            }
+            const lifecycle = await observePlacedOrderLifecycle(platformClient, autonomy.ownerWallet, guarded.receipt.order_ids);
+            if (notional !== null)
+                autonomy.dailyBudget.record(notional, nowMs());
+            return toolResult({
+                executed: true,
+                submission_state: guarded.status?.status === "submitted"
+                    ? "confirmed"
+                    : guarded.status?.status ?? "submitted_unverified",
+                order_state: lifecycle.state,
+                receipt: guarded.receipt,
+                order_status: guarded.status,
+                order_status_error: guarded.statusError,
+                lifecycle,
+                dead_man: guarded.deadMan,
+                notional_usd: notional,
+                ...(resolved === null ? {} : { resolved_intent: resolved.resolution }),
+            }, `Placed guarded ${side} order ${guarded.receipt.order_ids.join(", ")} as ${guarded.receipt.signature}.`);
+        }
+        const receipt = await platformClient.orders.execute(marketId, {
             operation: operation,
             signer: autonomy.signer,
-            ...(args.idempotencyKey === undefined ? {} : { idempotencyKey: args.idempotencyKey }),
+            idempotencyKey,
         });
         if (notional !== null)
             autonomy.dailyBudget.record(notional, nowMs());
-        return toolResult({ executed: true, receipt, notional_usd: notional }, `Executed ${receipt.action} control ${receipt.order_control_id} as ${receipt.signature}.`);
+        return toolResult({
+            executed: true,
+            receipt,
+            notional_usd: notional,
+            ...(resolved === null ? {} : { resolved_intent: resolved.resolution }),
+        }, `Executed ${receipt.action} control ${receipt.order_control_id} as ${receipt.signature}.`);
     }));
     // ── one-shot TWAP (schedule / cancel) ─────────────────────────────────────
     registerTool("strata_twap_execute", {
@@ -2444,6 +2958,9 @@ function registerAutonomyTools(registerTool, client, platformClient, autonomy, n
             openWorldHint: true,
         },
     }, async (args) => safeTool(async () => {
+        const autonomy = await autonomyProvider();
+        if (!autonomy)
+            return tradingNotConnected();
         let operation;
         if (args.action === "cancel") {
             if (args.twapId === undefined)
@@ -2540,7 +3057,7 @@ async function guardedTool(client, capabilityId, operation) {
     }
     catch (error) {
         if (error instanceof StrataApiError) {
-            return toolError(error.code, friendlyApiError(error.code, error.message), error.retryable);
+            return toolError(error.code, friendlyApiError(error.code, error.message), error.retryable, error.retryAfterMs);
         }
         return toolError("request_failed", safeMessage(error), true);
     }
@@ -2551,7 +3068,7 @@ async function safeTool(operation) {
     }
     catch (error) {
         if (error instanceof StrataApiError) {
-            return toolError(error.code, friendlyApiError(error.code, error.message), error.retryable);
+            return toolError(error.code, friendlyApiError(error.code, error.message), error.retryable, error.retryAfterMs);
         }
         return toolError("request_failed", safeMessage(error), true);
     }
@@ -2564,7 +3081,7 @@ async function retryReadOnce(operation) {
     catch (error) {
         if (!(error instanceof StrataApiError) || !error.retryable)
             throw error;
-        await new Promise((resolve) => setTimeout(resolve, 150));
+        await new Promise((resolve) => setTimeout(resolve, error.retryAfterMs ?? 150));
         return operation();
     }
 }
@@ -2596,8 +3113,16 @@ function toolResult(value, summary) {
         structuredContent: value,
     };
 }
-function toolError(code, message, retryable) {
-    const error = { error: { code, message, retryable } };
+function toolError(code, message, retryable, retryAfterMs, details) {
+    const error = {
+        error: {
+            code,
+            message,
+            retryable,
+            ...(retryAfterMs === undefined ? {} : { retry_after_ms: retryAfterMs }),
+            ...(details === undefined ? {} : { details }),
+        },
+    };
     return {
         isError: true,
         content: [{ type: "text", text: JSON.stringify(error) }],

package/dist/src/usability.js

@@ -17,6 +17,7 @@ export const SIMPLE_TOOL_NAMES = new Set([
     "strata_market_making_intent_execute",
     "strata_autonomy",
     "strata_trade",
+    "strata_order_execute",
 ]);
 export function parseToolMode(raw) {
     const value = raw?.trim().toLowerCase() || "simple";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stratabook/mcp",
-  "version": "0.2.17",
+  "version": "0.2.18",
   "description": "Connect AI agents to Strata markets and Sonar quotes with MCP.",
   "type": "module",
   "license": "MIT OR Apache-2.0",
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
-    "@stratabook/sdk": "0.2.17",
+    "@stratabook/sdk": "0.2.18",
     "zod": "^3.25.76"
   },
   "devDependencies": {