@stratabook/mcp 0.1.12 → 0.2.0

package/README.md

@@ -1,8 +1,8 @@
 # Strata MCP
 
-Official capability-gated MCP access to Strata and Sonar. The server is a thin adapter
-over `@stratabook/sdk`: it follows the live capability catalog and contains no
-private execution logic.
+Official capability-gated MCP access to Strata and Sonar. The server delegates
+to `@stratabook/sdk`: it follows the live capability catalog and contains no
+separate quote or execution logic.
 
 ## Local stdio
 
@@ -27,11 +27,36 @@ The tools currently available are:
 
 - `strata_capabilities`
 - `strata_action_graph`
+- `strata_platform_graph`
+- `strata_status`
+- `strata_candles`
+- `strata_marks`
+- `strata_twaps`
+- `strata_twap_challenge`
+- `strata_twap_cancel`
+- `strata_twap_prepare`
+- `strata_twap_submit`
+- `strata_portfolio`
+- `strata_portfolio_history`
+- `strata_market_making_status`
+- `strata_market_making_reputation`
+- `strata_vault_status`
+- `strata_vault_setup`, `strata_vault_deposit`, `strata_vault_withdraw`, `strata_vault_delegate`, `strata_vault_policy`, `strata_vault_pause` — prepare owner actions with Strata as sponsored fee payer
+- `strata_vault_submit` — submit the owner-signed preparation; Strata pays and broadcasts
+- `strata_vault_submission` — durable outcome of a submission
+- `strata_rewards`
+- `strata_referrals`
+- `strata_referral_link` — prepare externally signable consent or submit the signed link
+- `strata_referral_claim` — prepare externally signable consent or submit the signed claim
+- `strata_bugs`
+- `strata_bug_submit` — prepare externally signable bytes or submit the signed report
 - `strata_markets`, when `markets.read` is enabled for MCP
-- `strata_quote`, when `quotes.read` is enabled for MCP
+- `strata_quote` and `strata_exact_output_quote` (spend X / receive at least Y), when market quotes are enabled for MCP
+- `strata_swap_quote`, when catalog-asset swap quotes are enabled for MCP
 - `strata_execution_challenge`, when `trade.prepare` is enabled for MCP
 - `strata_execution_prepare`, when `trade.prepare` is enabled for MCP
 - `strata_execution_submit`, when `trade.submit` is enabled for MCP
+- `strata_execution_status` — recover a durable immediate-execution receipt
 - `strata_order_challenge`, when `orders.prepare` is enabled for MCP
 - `strata_order_prepare`, when `orders.prepare` is enabled for MCP
 - `strata_order_submit`, when `orders.submit` is enabled for MCP
@@ -42,7 +67,8 @@ server also publishes the complete harness as the
 `strata://agent-harness/v1` resource and provides a `strata_start` prompt for
 applying it to one concrete objective.
 The live executable topology is also available as
-`strata://action-graph/v1`.
+`strata://action-graph/v1`. The complete entity, operation, and workflow map is
+available as `strata://platform-graph/v2`.
 
 The tool list follows the live public policy. Every call rechecks that policy,
 so a disabled capability stops immediately even if a client cached an older
@@ -75,13 +101,14 @@ manifest at `/.well-known/strata-agent.json` and the graph at
 ## Safety
 
 The external agent owner decides what its agent may do and configures its
-signer. MCP can request authorization bytes, prepare quote-bound trades or
-atomic place, cancel, cancel-all, replace, or bounded batch order controls, and
+signer. MCP can request authorization bytes, prepare quote-bound trades,
+bounded TWAP placement or cancellation, or atomic place, cancel, cancel-all,
+replace, or bounded batch order controls, and
 submit the externally signed result. It accepts
 public keys, detached signatures, and signed transactions, never private keys,
 seed phrases, or wallet secrets. Amounts are token atoms encoded as base-10
 strings.
 
-Quotes default to zero execution tolerance. An agent can request a non-zero
-`slippageBps` explicitly when its task accepts a lower minimum output; price
-impact remains a separate measure of current market depth.
+Quotes default to zero tolerance. `maximumToleranceBps` is the agent's own
+floor (the most it accepts below the quoted output); `price_impact_pct` is
+measured from the book. They are unrelated, and every quote result states both.

package/dist/src/autonomy.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Session autonomy — the user-owned "how much may the agent finish by itself"
+ * slider, enforced inside the MCP server.
+ *
+ * The default is `ask`: the MCP prepares trades but never signs them, so the
+ * human signs every one. This is the calm default and it is unchanged from a
+ * server with no session key at all. A user who wants unattended, popup-free
+ * trading opts in by giving the MCP a Vault **session** secret key (capped and
+ * revocable on-chain) and raising the level:
+ *
+ *   - `ask`     — read + prepare only; the agent hands back an unsigned
+ *                 transaction for the human to sign. Never signs.
+ *   - `limits`  — signs and submits instantly, but only within an extra
+ *                 MCP-side ceiling (per-trade USD, per-day USD, allowed
+ *                 markets). Anything above stops and hands back a prepare.
+ *   - `instant` — signs and submits instantly within the on-chain session
+ *                 caps (the owner's per-asset limits, tolerance, interval,
+ *                 expiry). Hyperliquid-style.
+ *
+ * Withdraw, policy, pause, and revoke are never on this slider — they always
+ * require the owner's wallet. The on-chain session caps are the hard ceiling;
+ * this slider is a softer layer above them. An agent can *read* the level
+ * (`strata_autonomy`) and *offer* to change it, but nothing an agent calls can
+ * raise its own autonomy: the only knob is the human's (env / Agents page).
+ */
+import { StrataPlatformClient, type StrataSessionSigner } from "@stratabook/sdk";
+export declare const AUTONOMY_LEVELS: readonly ["ask", "limits", "instant"];
+export type AutonomyLevel = (typeof AUTONOMY_LEVELS)[number];
+export interface AutonomyConfig {
+    readonly level: AutonomyLevel;
+    /** `limits` only: the most one trade may be, in USD. Undefined = no per-trade cap. */
+    readonly maxUsdPerTrade?: number;
+    /** `limits` only: the most all trades may total per UTC day, in USD. */
+    readonly maxUsdPerDay?: number;
+    /** `limits` only: opaque market IDs the agent may trade. Empty = every live market. */
+    readonly allowedMarketIds?: readonly string[];
+}
+export interface SessionAutonomy {
+    readonly signer: StrataSessionSigner;
+    readonly ownerWallet: string;
+    readonly config: AutonomyConfig;
+    readonly dailyBudget: DailyUsdBudget;
+}
+/** 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. */
+export declare function sessionAutonomyFromEnv(env: Record<string, string | undefined>): Promise<SessionAutonomy | null>;
+/** In-memory per-UTC-day USD ledger. Resets on day change and on process restart. */
+export declare class DailyUsdBudget {
+    private day;
+    private spent;
+    private roll;
+    spentToday(nowMs: number): number;
+    record(usd: number, nowMs: number): void;
+}
+export type AutonomyDecision = {
+    readonly allow: true;
+} | {
+    readonly allow: false;
+    readonly reason: string;
+};
+/**
+ * Decide whether a trade of `notionalUsd` on `marketId` may be signed now.
+ * `notionalUsd` null means the notional could not be established — treated as
+ * over budget under `limits` (fail closed), ignored under `instant`.
+ */
+export declare function decideAutonomy(autonomy: SessionAutonomy, marketId: string, notionalUsd: number | null, nowMs: number): AutonomyDecision;
+/** A single cached join of platform market_id → its decimals + label. */
+interface MarketMeta {
+    readonly label: string;
+    readonly baseDecimals: number;
+    readonly quoteDecimals: number;
+}
+/**
+ * Resolve base/quote decimals for opaque platform market IDs by joining the
+ * platform market list (market_id ↔ label) with the Sonar market list
+ * (label ↔ decimals). Cached briefly; both are cheap public reads.
+ */
+export declare class MarketMetaResolver {
+    private readonly platformClient;
+    private readonly sonarMarkets;
+    private readonly nowMs;
+    private byId;
+    private labelToId;
+    private fetchedAtMs;
+    constructor(platformClient: Pick<StrataPlatformClient, "markets">, sonarMarkets: () => Promise<ReadonlyArray<{
+        label: string;
+        base_decimals: number;
+        quote_decimals: number;
+    }>>, nowMs: () => number);
+    private load;
+    get(marketId: string): Promise<MarketMeta | null>;
+    /** Opaque platform market_id for a Sonar market label, or null if unknown. */
+    idForLabel(label: string): Promise<string | null>;
+}
+/**
+ * USD notional of an order/TWAP of `baseAtoms` base on `marketId`, from the
+ * current mark. Best effort: returns null (→ fail closed under `limits`) when
+ * decimals or a fresh mark are unavailable. Cancels pass `baseAtoms = 0n`.
+ */
+export declare function estimateBaseNotionalUsd(resolver: MarketMetaResolver, markPriceAtomsPerBase: (marketId: string) => Promise<{
+    price_atoms_per_base_unit: string | null;
+    quote_decimals: number;
+    stale: boolean;
+}>, marketId: string, baseAtoms: bigint): Promise<number | null>;
+/** USD notional of a Sonar quote: the quote-asset side, exact from the quote. */
+export declare function quoteNotionalUsd(side: "buy" | "sell", amountInAtoms: string, minimumOutputAtoms: string, quoteDecimals: number): number | null;
+export {};

package/dist/src/autonomy.js

@@ -0,0 +1,230 @@
+/**
+ * Session autonomy — the user-owned "how much may the agent finish by itself"
+ * slider, enforced inside the MCP server.
+ *
+ * The default is `ask`: the MCP prepares trades but never signs them, so the
+ * human signs every one. This is the calm default and it is unchanged from a
+ * server with no session key at all. A user who wants unattended, popup-free
+ * trading opts in by giving the MCP a Vault **session** secret key (capped and
+ * revocable on-chain) and raising the level:
+ *
+ *   - `ask`     — read + prepare only; the agent hands back an unsigned
+ *                 transaction for the human to sign. Never signs.
+ *   - `limits`  — signs and submits instantly, but only within an extra
+ *                 MCP-side ceiling (per-trade USD, per-day USD, allowed
+ *                 markets). Anything above stops and hands back a prepare.
+ *   - `instant` — signs and submits instantly within the on-chain session
+ *                 caps (the owner's per-asset limits, tolerance, interval,
+ *                 expiry). Hyperliquid-style.
+ *
+ * Withdraw, policy, pause, and revoke are never on this slider — they always
+ * require the owner's wallet. The on-chain session caps are the hard ceiling;
+ * this slider is a softer layer above them. An agent can *read* the level
+ * (`strata_autonomy`) and *offer* to change it, but nothing an agent calls can
+ * raise its own autonomy: the only knob is the human's (env / Agents page).
+ */
+import { StrataContractError, sessionSignerFromSecretKey, } from "@stratabook/sdk";
+export const AUTONOMY_LEVELS = ["ask", "limits", "instant"];
+function positiveNumber(raw) {
+    if (raw === undefined)
+        return undefined;
+    const value = Number(raw.trim());
+    return Number.isFinite(value) && value > 0 ? value : undefined;
+}
+/** Parse the autonomy slider from a plain env bag; defaults to the calm `ask`. */
+export function parseAutonomyConfig(env) {
+    const raw = (env.STRATA_AUTONOMY ?? "ask").trim().toLowerCase();
+    const level = AUTONOMY_LEVELS.includes(raw)
+        ? raw
+        : "ask";
+    const maxUsdPerTrade = positiveNumber(env.STRATA_AUTONOMY_MAX_USD_PER_TRADE);
+    const maxUsdPerDay = positiveNumber(env.STRATA_AUTONOMY_MAX_USD_PER_DAY);
+    const allowedMarketIds = (env.STRATA_AUTONOMY_MARKETS ?? "")
+        .split(",")
+        .map((id) => id.trim())
+        .filter((id) => /^market_[0-9a-f]{32}$/.test(id));
+    return {
+        level,
+        ...(maxUsdPerTrade === undefined ? {} : { maxUsdPerTrade }),
+        ...(maxUsdPerDay === undefined ? {} : { maxUsdPerDay }),
+        ...(allowedMarketIds.length > 0 ? { allowedMarketIds } : {}),
+    };
+}
+/** Build the session-autonomy context from env, or null when no session key is set. */
+export async function sessionAutonomyFromEnv(env) {
+    const secret = env.STRATA_SESSION_SECRET_KEY?.trim();
+    const ownerWallet = env.STRATA_OWNER_WALLET?.trim();
+    if (!secret)
+        return null;
+    if (!ownerWallet || !/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(ownerWallet)) {
+        throw new StrataContractError("STRATA_SESSION_SECRET_KEY is set but STRATA_OWNER_WALLET is missing or invalid");
+    }
+    const expected = env.STRATA_SESSION_PUBLIC_KEY?.trim();
+    const signer = await sessionSignerFromSecretKey(secret, expected || undefined);
+    return {
+        signer,
+        ownerWallet,
+        config: parseAutonomyConfig(env),
+        dailyBudget: new DailyUsdBudget(),
+    };
+}
+/** In-memory per-UTC-day USD ledger. Resets on day change and on process restart. */
+export class DailyUsdBudget {
+    day = "";
+    spent = 0;
+    roll(nowMs) {
+        const day = new Date(nowMs).toISOString().slice(0, 10);
+        if (day !== this.day) {
+            this.day = day;
+            this.spent = 0;
+        }
+    }
+    spentToday(nowMs) {
+        this.roll(nowMs);
+        return this.spent;
+    }
+    record(usd, nowMs) {
+        this.roll(nowMs);
+        this.spent += Math.max(0, usd);
+    }
+}
+/**
+ * Decide whether a trade of `notionalUsd` on `marketId` may be signed now.
+ * `notionalUsd` null means the notional could not be established — treated as
+ * over budget under `limits` (fail closed), ignored under `instant`.
+ */
+export function decideAutonomy(autonomy, marketId, notionalUsd, nowMs) {
+    const { config } = autonomy;
+    if (config.level === "ask") {
+        return {
+            allow: false,
+            reason: "Autonomy is set to \"ask\": I prepared this trade but will not sign it. "
+                + "Sign the returned transaction yourself, or raise the slider to \"limits\" or \"instant\".",
+        };
+    }
+    if (config.level === "instant") {
+        return { allow: true };
+    }
+    // limits
+    if (config.allowedMarketIds && !config.allowedMarketIds.includes(marketId)) {
+        return {
+            allow: false,
+            reason: `Autonomy \"limits\" does not include this market. Allowed: ${config.allowedMarketIds.join(", ")}. `
+                + "Sign it yourself, add the market, or switch to \"instant\".",
+        };
+    }
+    if (notionalUsd === null) {
+        return {
+            allow: false,
+            reason: "Autonomy \"limits\" needs the trade's USD size to check the ceiling and I could not establish it, "
+                + "so I will not sign automatically. Sign the returned transaction yourself, or switch to \"instant\".",
+        };
+    }
+    if (config.maxUsdPerTrade !== undefined && notionalUsd > config.maxUsdPerTrade) {
+        return {
+            allow: false,
+            reason: `This trade is about $${notionalUsd.toFixed(2)}, over the per-trade limit of `
+                + `$${config.maxUsdPerTrade.toFixed(2)}. Sign it yourself, raise the limit, or switch to \"instant\".`,
+        };
+    }
+    if (config.maxUsdPerDay !== undefined) {
+        const remaining = config.maxUsdPerDay - autonomy.dailyBudget.spentToday(nowMs);
+        if (notionalUsd > remaining) {
+            return {
+                allow: false,
+                reason: `This trade is about $${notionalUsd.toFixed(2)} but only $${Math.max(0, remaining).toFixed(2)} `
+                    + `of today's $${config.maxUsdPerDay.toFixed(2)} budget is left. Sign it yourself or raise the daily budget.`,
+            };
+        }
+    }
+    return { allow: true };
+}
+const MARKET_META_TTL_MS = 60_000;
+/**
+ * Resolve base/quote decimals for opaque platform market IDs by joining the
+ * platform market list (market_id ↔ label) with the Sonar market list
+ * (label ↔ decimals). Cached briefly; both are cheap public reads.
+ */
+export class MarketMetaResolver {
+    platformClient;
+    sonarMarkets;
+    nowMs;
+    byId = null;
+    labelToId = new Map();
+    fetchedAtMs = 0;
+    constructor(platformClient, sonarMarkets, nowMs) {
+        this.platformClient = platformClient;
+        this.sonarMarkets = sonarMarkets;
+        this.nowMs = nowMs;
+    }
+    async load() {
+        if (this.byId && this.nowMs() - this.fetchedAtMs < MARKET_META_TTL_MS) {
+            return this.byId;
+        }
+        const byLabel = new Map();
+        for (const market of await this.sonarMarkets()) {
+            byLabel.set(market.label, {
+                baseDecimals: market.base_decimals,
+                quoteDecimals: market.quote_decimals,
+            });
+        }
+        const meta = new Map();
+        const labelToId = new Map();
+        let cursor;
+        for (let page = 0; page < 20; page += 1) {
+            const response = await this.platformClient.markets.list(cursor === undefined ? { limit: 100 } : { limit: 100, cursor });
+            for (const market of response.markets) {
+                labelToId.set(market.label, market.market_id);
+                const decimals = byLabel.get(market.label);
+                if (decimals) {
+                    meta.set(market.market_id, { label: market.label, ...decimals });
+                }
+            }
+            if (!response.page.has_more || response.page.next_cursor === null)
+                break;
+            cursor = response.page.next_cursor;
+        }
+        this.byId = meta;
+        this.labelToId = labelToId;
+        this.fetchedAtMs = this.nowMs();
+        return meta;
+    }
+    async get(marketId) {
+        return (await this.load()).get(marketId) ?? null;
+    }
+    /** Opaque platform market_id for a Sonar market label, or null if unknown. */
+    async idForLabel(label) {
+        await this.load();
+        return this.labelToId.get(label) ?? null;
+    }
+}
+/**
+ * USD notional of an order/TWAP of `baseAtoms` base on `marketId`, from the
+ * current mark. Best effort: returns null (→ fail closed under `limits`) when
+ * decimals or a fresh mark are unavailable. Cancels pass `baseAtoms = 0n`.
+ */
+export async function estimateBaseNotionalUsd(resolver, markPriceAtomsPerBase, marketId, baseAtoms) {
+    if (baseAtoms <= 0n)
+        return 0;
+    const meta = await resolver.get(marketId);
+    if (!meta)
+        return null;
+    const mark = await markPriceAtomsPerBase(marketId);
+    if (mark.stale || mark.price_atoms_per_base_unit === null)
+        return null;
+    const price = Number(mark.price_atoms_per_base_unit);
+    if (!Number.isFinite(price) || price <= 0)
+        return null;
+    const baseWhole = Number(baseAtoms) / 10 ** meta.baseDecimals;
+    const usd = (baseWhole * price) / 10 ** mark.quote_decimals;
+    return Number.isFinite(usd) ? usd : null;
+}
+/** USD notional of a Sonar quote: the quote-asset side, exact from the quote. */
+export function quoteNotionalUsd(side, amountInAtoms, minimumOutputAtoms, quoteDecimals) {
+    const quoteAtoms = side === "buy" ? amountInAtoms : minimumOutputAtoms;
+    const value = Number(quoteAtoms);
+    if (!Number.isFinite(value) || value < 0)
+        return null;
+    const usd = value / 10 ** quoteDecimals;
+    return Number.isFinite(usd) ? usd : null;
+}

package/dist/src/cli.js

@@ -5,6 +5,7 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import { DEFAULT_API_BASE } 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 { SERVER_VERSION } from "./version.js";
 function parse(argv) {
     const values = new Map();
@@ -160,10 +161,16 @@ function safeError(error) {
 }
 async function main() {
     const options = parse(process.argv.slice(2));
-    if (options.transport === "stdio")
-        await runStdio(options);
+    const sessionAutonomy = await sessionAutonomyFromEnv(process.env);
+    const withSession = sessionAutonomy ? { ...options, sessionAutonomy } : options;
+    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)}…)\n`);
+    }
+    if (withSession.transport === "stdio")
+        await runStdio(withSession);
     else
-        await runHttp(options);
+        await runHttp(withSession);
 }
 main().catch((error) => {
     process.stderr.write(`${error instanceof Error ? error.message : "Strata MCP failed to start."}\n`);

package/dist/src/generated-harness.d.ts

@@ -9,48 +9,86 @@ export declare const STRATA_AGENT_HARNESS: {
         readonly capabilities: "https://api.stratabook.app/sonar/capabilities";
         readonly markets: "https://api.stratabook.app/sonar/markets";
         readonly platform_capabilities: "https://api.stratabook.app/v2/capabilities";
+        readonly platform_action_graph: "https://api.stratabook.app/v2/action-graph";
+        readonly platform_status: "https://api.stratabook.app/v2/status";
         readonly platform_markets: "https://api.stratabook.app/v2/markets";
         readonly action_graph: "https://api.stratabook.app/sonar/action-graph";
         readonly mcp: "https://api.stratabook.app/mcp";
         readonly manifest: "https://api.stratabook.app/.well-known/strata-agent.json";
     };
     readonly interfaces: {
-        readonly mcp_tool_order: readonly ["strata_capabilities", "strata_action_graph", "strata_markets", "strata_quote", "strata_execution_challenge", "strata_execution_prepare", "strata_execution_submit", "strata_order_challenge", "strata_order_prepare", "strata_order_submit", "strata_order_status"];
-        readonly terminal: readonly ["npx -y @stratabook/sdk capabilities --json", "npx -y @stratabook/sdk action-graph --json", "npx -y @stratabook/sdk markets --json", "npx -y @stratabook/sdk quote --market SOL/USDC --side sell --amount-atoms 10000000 --json", "npx -y @stratabook/sdk order-slo --market-id MARKET_ID --owner-wallet OWNER_PUBLIC_KEY --json"];
+        readonly mcp_tool_order: readonly ["strata_capabilities", "strata_action_graph", "strata_platform_graph", "strata_status", "strata_markets", "strata_marks", "strata_candles", "strata_twaps", "strata_twap_challenge", "strata_twap_cancel", "strata_twap_prepare", "strata_twap_submit", "strata_portfolio", "strata_portfolio_history", "strata_market_making_status", "strata_market_making_reputation", "strata_vault_status", "strata_vault_setup", "strata_vault_deposit", "strata_vault_withdraw", "strata_vault_delegate", "strata_vault_policy", "strata_vault_pause", "strata_vault_submit", "strata_vault_submission", "strata_rewards", "strata_referrals", "strata_referral_link", "strata_referral_claim", "strata_bugs", "strata_bug_submit", "strata_quote", "strata_exact_output_quote", "strata_swap_quote", "strata_execution_challenge", "strata_execution_prepare", "strata_execution_submit", "strata_execution_status", "strata_order_challenge", "strata_order_prepare", "strata_order_submit", "strata_order_status"];
+        readonly terminal: readonly ["npx -y @stratabook/sdk capabilities --json", "npx -y @stratabook/sdk action-graph --json", "npx -y @stratabook/sdk platform-graph --json", "npx -y @stratabook/sdk platform-status --json", "npx -y @stratabook/sdk mark --market-id MARKET_ID --json", "npx -y @stratabook/sdk candles --market-id MARKET_ID --from-ms FROM_MS --to-ms TO_MS --resolution-seconds 300 --json", "npx -y @stratabook/sdk execution-status --market-id MARKET_ID --execution-id EXECUTION_ID --json", "npx -y @stratabook/sdk twaps --market-id MARKET_ID --wallet WALLET_PUBLIC_KEY --json", "npx -y @stratabook/sdk twap-challenge --market-id MARKET_ID --owner-wallet OWNER_PUBLIC_KEY --session-public-key SESSION_PUBLIC_KEY --side buy --total-size-atoms TOTAL_ATOMS --slices 10 --tolerance-bps 100 --interval-slots 100 --limit-price-atoms PRICE_ATOMS --json", "npx -y @stratabook/sdk twap-cancel --market-id MARKET_ID --owner-wallet OWNER_PUBLIC_KEY --session-public-key SESSION_PUBLIC_KEY --twap-id TWAP_ID --json", "npx -y @stratabook/sdk twap-prepare --market-id MARKET_ID --owner-wallet OWNER_PUBLIC_KEY --session-public-key SESSION_PUBLIC_KEY --side buy --total-size-atoms TOTAL_ATOMS --slices 10 --tolerance-bps 100 --interval-slots 100 --limit-price-atoms PRICE_ATOMS --json", "npx -y @stratabook/sdk twap-submit --market-id MARKET_ID --twap-control-id CONTROL_ID --signed-transaction-base64 TRANSACTION --idempotency-key KEY --json", "npx -y @stratabook/sdk account --wallet WALLET_PUBLIC_KEY --json", "npx -y @stratabook/sdk portfolio-history --wallet WALLET_PUBLIC_KEY --range 24h --json", "npx -y @stratabook/sdk maker-status --market-id MARKET_ID --wallet WALLET_PUBLIC_KEY --json", "npx -y @stratabook/sdk maker-reputation --market-id MARKET_ID --wallet WALLET_PUBLIC_KEY --json", "npx -y @stratabook/sdk vault-status --wallet WALLET_PUBLIC_KEY --session-public-key SESSION_PUBLIC_KEY --json", "npx -y @stratabook/sdk session-keygen --json", "npx -y @stratabook/sdk vault-setup --wallet WALLET_PUBLIC_KEY --session-public-key SESSION_PUBLIC_KEY --json", "npx -y @stratabook/sdk vault-deposit --wallet WALLET_PUBLIC_KEY --market-id MARKET_ID --asset-id ASSET_ID --amount-atoms AMOUNT --session-public-key SESSION_PUBLIC_KEY --json", "npx -y @stratabook/sdk vault-withdraw --wallet WALLET_PUBLIC_KEY --market-id MARKET_ID --asset-id ASSET_ID --destination-wallet DESTINATION_WALLET --amount-atoms AMOUNT --json", "npx -y @stratabook/sdk vault-delegate --wallet WALLET_PUBLIC_KEY --session-public-key SESSION_PUBLIC_KEY --action revoke --json", "npx -y @stratabook/sdk vault-policy --wallet WALLET_PUBLIC_KEY --mode restricted --allowed-wallets DESTINATION_WALLET --json", "npx -y @stratabook/sdk vault-pause --wallet WALLET_PUBLIC_KEY --paused true --json", "npx -y @stratabook/sdk rewards --wallet WALLET_PUBLIC_KEY --json", "npx -y @stratabook/sdk referrals --wallet WALLET_PUBLIC_KEY --json", "npx -y @stratabook/sdk referral-link --wallet WALLET_PUBLIC_KEY --code REFERRAL_CODE --json", "npx -y @stratabook/sdk referral-claim --wallet WALLET_PUBLIC_KEY --json", "npx -y @stratabook/sdk bugs --wallet WALLET_PUBLIC_KEY --json", "npx -y @stratabook/sdk bug-payload --message REPORT_TEXT --json", "npx -y @stratabook/sdk markets --json", "npx -y @stratabook/sdk quote --market SOL/USDC --side sell --amount-atoms 10000000 --json", "npx -y @stratabook/sdk swap-quote --input-asset-id INPUT_ASSET_ID --output-asset-id OUTPUT_ASSET_ID --amount-atoms 10000000 --json", "npx -y @stratabook/sdk order-slo --market-id MARKET_ID --owner-wallet OWNER_PUBLIC_KEY --json"];
     };
     readonly workflow: readonly [{
         readonly id: "discover_capabilities";
         readonly instruction: "Read the live capability catalog before every objective. Never infer permission from documentation, package support, or an earlier session.";
     }, {
         readonly id: "establish_mode";
-        readonly instruction: "Read the action graph and identify which prepare and submit nodes are live. The external agent owner configures its permissions and signer authority; static documentation never enables a Strata operation.";
+        readonly instruction: "Read the compact action graph and the complete platform graph, then identify which operation and workflow nodes are live. The external agent owner configures its permissions and signer authority; static documentation never enables a Strata operation.";
     }, {
         readonly id: "understand_objective";
-        readonly instruction: "Resolve the user's market, side, amount, and tolerance. Ask before proceeding when any economically meaningful input is ambiguous.";
+        readonly instruction: "Resolve the user's market or input/output assets, side when applicable, amount, and tolerance. Ask before proceeding when any economically meaningful input is ambiguous.";
     }, {
         readonly id: "discover_market";
-        readonly instruction: "List markets, select one marked ready, and use its discovered base and quote decimals. Do not guess market identifiers or token decimals.";
+        readonly instruction: "List catalog assets and markets, select currently available product identities, and use discovered decimals. Do not guess identifiers or token decimals.";
     }, {
         readonly id: "read_market_data";
         readonly instruction: "When books.read is live, use the opaque market ID to read the Strata book, status, fees, and recent trades. Subscribe to the market stream for changes and recover from any sequence gap with a fresh snapshot.";
     }, {
         readonly id: "read_account";
-        readonly instruction: "When account.read is live, use the owner-configured signer to authorize the exact wallet, market, request time, and fill limit. Read or stream only the sanitized orders and fills returned by the official SDK, and recover stream gaps from a fresh signed snapshot.";
+        readonly instruction: "Read the whole account with one public call by wallet address (portfolio.read / strata_portfolio / `account.read(wallet)`): balances, positions, open orders, and recent fills across every live market — no signature, no session key, no market selection. Per-market signed account reads and streams (account.read / account.stream) exist only for owners who want a signed, per-market view; never make them a prerequisite for trading.";
+    }, {
+        readonly id: "read_portfolio";
+        readonly instruction: "Before sizing any action, read the account once (portfolio.read): exact per-asset total, available, and locked atoms, per-market positions, open orders, recent fills, and USD totals with the observed slot. Treat null USD totals as an incomplete valuation, never as zero; markets listed in unavailable_market_ids did not report orders and fills for that snapshot; use the typed stored-history operation for past equity.";
+    }, {
+        readonly id: "read_vault";
+        readonly instruction: "Before session-owned execution, read the official Vault status for the owner and external session key. Continue only when the product is active, the session is active, and market_execution_ready is true; treat opaque asset limits and withdrawal access as authoritative.";
+    }, {
+        readonly id: "protect_vault";
+        readonly instruction: "When an owner requests a Vault pause or resume and vault.pause is live, prepare the exact transaction with the official SDK, verify that the wallet and requested state are unchanged, then have the owner-configured signer sign and broadcast it externally. Preparation alone does not change state.";
+    }, {
+        readonly id: "onboard_vault";
+        readonly instruction: "Onboarding is one owner signature, once: register the external session key with vault.setup (only the wallet and the session key are required; one session then trades every market) or simply name the session key on the first vault.deposit, which registers it in the same transaction. Policy fields — expiry, cadence, tolerance, per-asset limits — are optional. Verify every echoed field and the prepared transaction before external owner signing and broadcast; retain the session key only in the owner's signer.";
+    }, {
+        readonly id: "fund_vault";
+        readonly instruction: "When vault.deposit is live, select an asset from the discovered market and use an exact positive atomic amount. Verify the echoed owner, market, asset, and amount plus the prepared transaction before external owner signing and broadcast.";
+    }, {
+        readonly id: "withdraw_vault";
+        readonly instruction: "When vault.withdraw is live, choose an exact market asset, destination-owner wallet, and positive atomic amount. Verify every echoed binding and the prepared transaction before external owner signing and broadcast; the on-chain withdrawal policy remains authoritative.";
+    }, {
+        readonly id: "revoke_vault_session";
+        readonly instruction: "When an owner requests session revocation and vault.delegate.manage is live, bind the exact owner wallet and external session public key. Verify both identities and the destructive revoke action before external owner signing and broadcast; preparation alone does not revoke access.";
+    }, {
+        readonly id: "control_vault_withdrawals";
+        readonly instruction: "When vault.policy.manage is live, use blocked mode with no allowed wallets to freeze withdrawals or restricted mode with one to eight exact destination-owner wallets. Verify the echoed mode and complete wallet list before external owner signing and broadcast.";
+    }, {
+        readonly id: "reconcile_maker_status";
+        readonly instruction: "When mm.status.read is live, read the maker's products by wallet address (public, no signature) before and after any maker action: resting firm orders, the intent budget, live signed quotes, each Strand and Current with its remaining exposure and expiry, oracle health, and armed dead-man guards. Reconcile against what the agent believes it posted; treat missing, expired, or disabled products as not quoting.";
+    }, {
+        readonly id: "stream_maker_fills";
+        readonly instruction: "When mm.fills.stream is live, keep one maker stream open per market through the official SDK by wallet address (public, no signature): start from the maker snapshot, apply only contiguous maker_fill and maker_status events, and recover any gap or reconnect from a fresh snapshot. Reconcile every fill and exposure change against the maker's own state before quoting further.";
+    }, {
+        readonly id: "inspect_maker_reputation";
+        readonly instruction: "When mm.reputation.read is live, read the maker's record by wallet address (public, no signature). Use the tier, reliability counters, tier-progress gates, signed-quote eligibility, and minimum cadence before choosing the maker transport; do not infer hidden counterparties or execution paths.";
     }, {
         readonly id: "preserve_atoms";
         readonly instruction: "Represent token amounts as unsigned base-10 atomic strings. Never pass settlement amounts through floating-point arithmetic.";
+    }, {
+        readonly id: "authorize_community_actions";
+        readonly instruction: "For referral link or claim actions, generate the exact official SDK authorization payload, have the affected owner wallet sign it externally, and submit only the detached signature with the same referral code or payout wallet binding.";
     }, {
         readonly id: "request_quote";
-        readonly instruction: "Request a fresh Sonar quote with an explicit side, exact input atoms, and execution tolerance supplied by the external agent.";
+        readonly instruction: "Request a fresh Sonar quote using either a selected market and explicit side or selected input/output asset IDs, plus exact input atoms and the execution tolerance supplied by the external agent.";
     }, {
         readonly id: "validate_quote";
-        readonly instruction: "Verify the quote binds to the selected market, side, and input. Check labelled fees, minimum output, price impact, server time, and expiry.";
+        readonly instruction: "Verify the quote binds to the selected market and side or the selected input/output assets, plus the exact input and tolerance. Check labelled fees, minimum output, price impact, server time, and expiry.";
     }, {
         readonly id: "report_result";
         readonly instruction: "Report consumed input, expected output, minimum output, fees by asset side, price impact, and remaining validity.";
     }, {
         readonly id: "authorize_writes";
-        readonly instruction: "When prepare and submit are exposed, keep signing external to Strata: request canonical authorization bytes, sign them with the owner-configured signer, verify the prepared transaction preserves the quote or exact opaque order set, then submit the externally signed transaction with idempotency. Resting-order control supports place, cancel, bounded cancel-all, atomic replace, and atomic heterogeneous batches of up to six operations. Every incoming resting order selects an explicit self-trade prevention policy; no policy permits a self-fill.";
+        readonly instruction: "When prepare and submit are exposed, keep signing external to Strata and use one signature per action: send the operation itself to prepare (orders, TWAP, quote-bound execution), verify the returned transaction, sign only that transaction with the session key, then submit with idempotency. The SDK's built-in verifier decodes the transaction and requires it to be exactly the requested operation for that market with the session co-signing only delegated instructions and never paying; a stricter owner verifier may replace it. The two-step challenge path (authorization bytes signed first) remains available. Resting-order control supports place, cancel, bounded cancel-all, atomic replace, and atomic heterogeneous batches of up to six operations. Every incoming resting order selects an explicit self-trade prevention policy; no policy permits a self-fill.";
     }, {
         readonly id: "stream_order_commands";
         readonly instruction: "When orders.prepare and orders.submit advertise websocket transport, use the official SDK persistent order-command connection. Sign its owner/session/market challenge externally, require contiguous sequences and correlated request IDs, treat the submit result as RPC broadcast only, and consume the pushed terminal status without blocking the placement hot path.";
@@ -60,12 +98,18 @@ export declare const STRATA_AGENT_HARNESS: {
     }, {
         readonly id: "certify_order_command_slo";
         readonly instruction: "Use the official non-trading order-command certification harness before release and on the production schedule. Retain its machine-readable connection count, load, latency percentiles, sequence/error rate, thresholds, and pass/fail result; package support alone is not a latency claim.";
+    }, {
+        readonly id: "stream_execution_state";
+        readonly instruction: "When execution.stream is live, watch every execution handle you prepared through the official SDK's sequenced execution stream instead of polling status: start from its snapshot, apply only contiguous execution_update, execution_expired, and execution_unknown events, recover any gap from a fresh snapshot, and treat an expired or unknown handle as not executed unless a confirmed receipt says otherwise.";
+    }, {
+        readonly id: "stream_twap_progress";
+        readonly instruction: "When algos.twap.stream is live, keep the official SDK's TWAP stream open for the owner wallet across the markets with active schedules: start from the snapshot, apply only contiguous twap_update events, and recover any gap from a fresh snapshot. Report executed size, achieved value, fees, and the terminal receipt from the streamed rows rather than polling.";
     }, {
         readonly id: "monitor_outcome";
         readonly instruction: "After an authorized submission, report the RPC-broadcast receipt and then the durable terminal status or explicit failure. If the request times out or either process restarts, recover it with the same control ID and idempotency key. Never claim chain completion from preparation, signing, or the immediate broadcast receipt.";
     }];
     readonly stop_conditions: readonly ["The required live capability is disabled or absent.", "The market is paused, unavailable, or has no reviewed operation path.", "Market, side, amount, decimals, tolerance, or signer authority is unavailable or ambiguous.", "The contract version is unsupported or a response contains unknown fields.", "A quote is expired or its market, side, amount, fee, minimum-output, or time binding is inconsistent.", "A requested operation exceeds the exposed tool, account, or policy scope.", "A user asks the agent to receive or expose wallet secrets, private keys, seed phrases, session keys, or production credentials."];
-    readonly safety_rules: readonly ["Never request or accept wallet secrets, private keys, seed phrases, session keys, or production credentials in a prompt.", "Never call undocumented endpoints or reconstruct private Sonar behavior.", "Never silently widen slippage, refresh changed economics, substitute a market, or retry a non-retryable failure.", "Never select a self-trade policy implicitly, suppress an order-command sequence gap, or disarm a dead-man ticket merely because the client is shutting down.", "Treat capability removal, revocation, expiry, and emergency disable as immediate stop signals.", "Capability and action-graph availability are authoritative for Strata operations; permission and signer policy remain controlled by the external agent owner."];
+    readonly safety_rules: readonly ["Never request or accept wallet secrets, private keys, seed phrases, session keys, or production credentials in a prompt.", "Never call undocumented endpoints or reconstruct private Sonar behavior.", "Never silently widen the tolerance, refresh changed economics, substitute a market, or retry a non-retryable failure.", "Never select a self-trade policy implicitly, suppress an order-command sequence gap, or disarm a dead-man ticket merely because the client is shutting down.", "Treat capability removal, revocation, expiry, and emergency disable as immediate stop signals.", "Capability and action-graph availability are authoritative for Strata operations; permission and signer policy remain controlled by the external agent owner."];
 };
 export declare const STRATA_AGENT_HARNESS_URI = "strata://agent-harness/v1";
 export declare const STRATA_ACTION_GRAPH: {
@@ -507,4 +551,4 @@ export declare const STRATA_ACTION_GRAPH: {
     }];
 };
 export declare const STRATA_ACTION_GRAPH_URI = "strata://action-graph/v1";
-export declare const STRATA_AGENT_HARNESS_INSTRUCTIONS = "Strata Agent Harness 1.0. Start every objective with strata_capabilities, then strata_action_graph, then strata_markets. Read strata://agent-harness/v1 and strata://action-graph/v1. The external agent owner controls permission and signer authority. Strata accepts public keys, detached signatures, and signed transactions, never private keys or seed phrases. Resolve the market, side, exact input atoms, and tolerance before strata_quote. Treat amounts as unsigned base-10 token atoms; check quote bindings, labelled fees, minimum output, and expiry. To execute or control a resting order: request a challenge, verify its quote or exact opaque order bindings, sign canonical authorization bytes externally, prepare, verify and sign the returned transaction externally, then submit with idempotency. When websocket order transport is live, prefer the official SDK persistent command stream, choose explicit self-trade prevention, keep its durable dead-man guard armed for resting exposure, and distinguish immediate RPC broadcast from pushed terminal chain status. If submission is ambiguous, recover durable status with the same control ID and idempotency key. Order control supports place, cancel, bounded cancel-all, atomic replace, and atomic heterogeneous batches of up to six operations. Stop on ambiguity, sequence gaps, unavailable capabilities, paused markets, unsupported contracts, inconsistent bindings, expiry, or missing signer authority.";
+export declare const STRATA_AGENT_HARNESS_INSTRUCTIONS = "Strata Agent Harness 1.0. Start every objective with strata_capabilities, then strata_action_graph, then strata_platform_graph, then strata_status, then strata_markets. Read strata://agent-harness/v1, strata://action-graph/v1, and strata://platform-graph/v2. The external agent owner controls permission and signer authority. Strata accepts public keys, detached signatures, and signed transactions, never private keys or seed phrases. Resolve a market and side or catalog input/output asset IDs, plus exact input atoms and tolerance, before strata_quote or strata_swap_quote. When portfolio.read is live, read the owner's live Vault portfolio before sizing any action and treat null USD totals as an incomplete valuation, never as zero. When mm.status.read is live, reconcile the owner's own maker products, exposure, and dead-man guards through the authorized status read before and after every maker action, and when mm.fills.stream is live keep the official SDK's authenticated maker stream open to apply contiguous maker fills and exposure changes. When algos.twap.stream is live, follow TWAP progress through the official SDK's sequenced TWAP stream instead of polling, and when execution.stream is live watch prepared execution handles through the sequenced execution stream. Before selecting a maker transport, read the externally authorized owner-scoped maker reputation record and follow its signed-quote eligibility, cadence, and tier-progress fields. Treat amounts as unsigned base-10 token atoms; check quote bindings, labelled fees, minimum output, and expiry. To execute or control a resting order: request a challenge, verify its quote or exact opaque order bindings, sign canonical authorization bytes externally, prepare, verify and sign the returned transaction externally, then submit with idempotency. When websocket order transport is live, prefer the official SDK persistent command stream, choose explicit self-trade prevention, keep its durable dead-man guard armed for resting exposure, and distinguish immediate RPC broadcast from pushed terminal chain status. If submission is ambiguous, recover durable status with the same control ID and idempotency key. Order control supports place, cancel, bounded cancel-all, atomic replace, and atomic heterogeneous batches of up to six operations. Stop on ambiguity, sequence gaps, unavailable capabilities, paused markets, unsupported contracts, inconsistent bindings, expiry, or missing signer authority.";