@intent-engine/cli 0.1.23 → 0.1.27

package/dist/src/args.js

@@ -1,11 +1,22 @@
 import { parseArgs } from "node:util";
-import { MAX_PRIORITY_PRICE } from "./compute.js";
-import { MAX_EXPIRES_IN } from "./agent/create.js";
-import { MANDATE_KIND_NAMES } from "./agent/mandate.js";
+import { AUTO_PRICE_CAP } from "./compute.js";
 import { MAX_SUBMIT_WITHIN } from "./agent/signed.js";
-import { DEVNET_URL, tokenNamed } from "./tokens.js";
-import { address } from "@solana/kit";
-import { I64_MAX, I64_MIN, isMemoUrl, Kind, kindBit, MAX_PARTNER_BPS, MEMO_URL_RULE, TOKEN_AMOUNT_PATTERN, U64_MAX, } from "@intent-engine/core";
+import { DEVNET_URL } from "./tokens.js";
+import { ACCEPTS, OPTIONS } from "./arg-options.js";
+import { addressList, amountOf, https, key, memoUrlOf, mintList, named, noRepeats, noSub, onlyAccepted, optionalField, outputOf, parseAddress, parseBounded, parseFeeBps, parseI64, parseKindFees, parseKinds, parseLimit, parseMaxRent, parsePause, parsePriority, parseSolCost, required, sha256Of, u64, unitsOf, UsageError, } from "./arg-values.js";
+import { agentSpec, authorityOf, configChange, JUDGE_TIMEOUT, market, MAX_JUDGE_TIMEOUT, maxPagesOf, profitFloors, relaySpec, releaseOption, runOf, solveFeeAboveCap, treasury, walletLimits, } from "./command-builders.js";
+import { createTerms, mandate, terms } from "./order-builders.js";
+import { USAGE } from "./arg-usage.js";
+import { sandboxOf } from "./sandbox.js";
+import { committeeOf, feedbackOf, reputationOf } from "./trust-args.js";
+import { monitorOf } from "./monitor-args.js";
+import { DEFAULT_MAX_RENT, DEFAULT_MAX_SOL_COST } from "@intent-engine/solver";
+import { MIN_CAP_WINDOW_SECS } from "@intent-engine/core";
+export { ACCEPTS, GLOBAL_OPTIONS, SUB_ACCEPTS, TOKEN_SIDES } from "./arg-options.js";
+export { COMMANDS, SHAPES, USAGE, usageOf } from "./arg-usage.js";
+export { MAX_EVENT_LIMIT, MAX_RENT_FORMAT, MAX_SOL_COST_FORMAT, outputOf, parseFeeBps, parseI64, parseKinds, parseLimit, parseMaxRent, parsePause, parsePriority, parseSolCost, parseU64, SHA256_NEEDED, UsageError, } from "./arg-values.js";
+export { expiry, MANDATE_USE_KINDS, needsSpecHash, order, SPEC_HASH_FORMAT } from "./order-builders.js";
+export { AGENT_DEFAULT_HOURLY_LAMPORTS, AGENT_NEEDS_OWNERS, ISSUE_ALONE, ISSUE_FORMAT, JUDGE_TIMEOUT, MAX_DELIVERY_PAGES, MAX_JUDGE_TIMEOUT, ONE_MARKET, RELAY_DEFAULT_HOURLY_LAMPORTS, RELAY_DEFAULT_TTL, RELAY_MAX_TTL, RELAY_NEEDS_FEES, RELEASE_NEEDED, RUN_NEEDED, solveFeeAboveCap, TREASURY_CREATE_NEEDS_MINTS, WALLET_LIMITS_NEED_WALLET, zeroProfit, } from "./command-builders.js";
 export const DEFAULT_URL = "http://127.0.0.1:8899";
 export const CLUSTERS = {
     localnet: DEFAULT_URL,
@@ -18,923 +29,11 @@ export const ENV_KEYPAIR = "INTENT_ENGINE_KEYPAIR";
 const SETUP_CLUSTER = "devnet";
 export const WALLET_NOT_MAINNET = "mcp --wallet keeps its key in a file on this machine, so it serves devnet, testnet and localnet only";
 const BALANCE_OF_ONE = "balance takes --keypair or --owner, not both";
-export const GLOBAL_OPTIONS = ["output", "help"];
-export class UsageError extends Error {
-}
-export const RELAY_NEEDS_FEES = "--relayer needs --relay-fee naming every input token it relays as mint=amount; amount may be 0, and other tokens are refused";
-export const AGENT_NEEDS_OWNERS = "--agent needs --agent-owners naming every owner whose mandates this agent key may use";
-export const RELAY_DEFAULT_TTL = 24 * 60 * 60;
-export const RELAY_DEFAULT_HOURLY_LAMPORTS = 100000000n;
-export const AGENT_DEFAULT_HOURLY_LAMPORTS = 50000000n;
-export const RELAY_MAX_TTL = 365 * 24 * 60 * 60;
-const RELAY_DEFAULT_PER_HOUR = 10;
-const RELAY_MIN_TTL = 60;
-export const TOKEN_SIDES = {
-    "amount-in": "input",
-    make: "input",
-    "per-intent": "input",
-    total: "input",
-    "agent-fee": "input",
-    "floor-in": "input",
-    "relayer-fee": "input",
-    amount: "input",
-    "min-out": "output",
-    take: "output",
-    "start-out": "output",
-    "end-out": "output",
-    "floor-out": "output",
-};
-const OPTIONS = {
-    url: { type: "string" },
-    keypair: { type: "string" },
-    relayer: { type: "string" },
-    agent: { type: "string" },
-    wallet: { type: "boolean" },
-    "wallet-per-trade": { type: "string" },
-    "wallet-per-hour": { type: "string" },
-    "relay-max-lamports": { type: "string" },
-    "relay-max-ttl": { type: "string" },
-    "relay-per-hour": { type: "string" },
-    "relay-hourly-lamports": { type: "string" },
-    "relay-fee": { type: "string" },
-    "priority-fee": { type: "string" },
-    authority: { type: "string" },
-    "fill-disabled": { type: "string" },
-    "new-admin": { type: "string" },
-    "agent-hourly-lamports": { type: "string" },
-    "agent-owners": { type: "string" },
-    owner: { type: "string" },
-    nonce: { type: "string" },
-    at: { type: "string" },
-    base: { type: "string" },
-    "input-mint": { type: "string" },
-    "output-mint": { type: "string" },
-    "expires-at": { type: "string" },
-    "amount-in": { type: "string" },
-    "min-out": { type: "string" },
-    make: { type: "string" },
-    take: { type: "string" },
-    guardian: { type: "string" },
-    "fee-recipient": { type: "string" },
-    "fee-bps": { type: "string" },
-    kinds: { type: "string" },
-    flags: { type: "string" },
-    "dry-run": { type: "boolean" },
-    yes: { type: "boolean" },
-    help: { type: "boolean" },
-    version: { type: "boolean" },
-    follow: { type: "boolean" },
-    watch: { type: "boolean" },
-    output: { type: "string" },
-    interval: { type: "string" },
-    "expires-in": { type: "string" },
-    "start-out": { type: "string" },
-    "end-out": { type: "string" },
-    "start-at": { type: "string" },
-    "end-at": { type: "string" },
-    "min-result": { type: "string" },
-    "max-result": { type: "string" },
-    attestor: { type: "string" },
-    "per-intent": { type: "string" },
-    total: { type: "string" },
-    "max-intents": { type: "string" },
-    "max-ttl": { type: "string" },
-    "valid-for": { type: "string" },
-    "floor-out": { type: "string" },
-    "floor-in": { type: "string" },
-    "agent-fee": { type: "string" },
-    id: { type: "string" },
-    mint: { type: "string" },
-    amount: { type: "string" },
-    out: { type: "string" },
-    file: { type: "string" },
-    "submit-within": { type: "string" },
-    "relayer-fee": { type: "string" },
-    units: { type: "string" },
-    "fund-accounts": { type: "boolean" },
-    limit: { type: "string" },
-    bounty: { type: "string" },
-    "create-fee": { type: "string" },
-    "kind-fees": { type: "string" },
-    "partner-cut": { type: "string" },
-    partner: { type: "string" },
-    jupiter: { type: "string" },
-    jito: { type: "string" },
-    tip: { type: "string" },
-    "min-profit": { type: "string" },
-    issue: { type: "string" },
-    "max-fee-bps": { type: "string" },
-    "slippage-bps": { type: "string" },
-    "route-program": { type: "string" },
-    "lookup-table": { type: "string" },
-    solver: { type: "string" },
-    "partner-bps": { type: "string" },
-    mints: { type: "string" },
-    create: { type: "boolean" },
-    intent: { type: "string" },
-    sha256: { type: "string" },
-    "work-url": { type: "string" },
-    spec: { type: "string" },
-    artifact: { type: "string" },
-    run: { type: "string" },
-    "pay-to": { type: "string" },
-    timeout: { type: "string" },
-    verdict: { type: "string" },
-};
-const KIND_NAMES = {
-    swap: Kind.SwapExactIn,
-    limit: Kind.LimitOrder,
-    dutch: Kind.DutchAuction,
-    attested: Kind.AttestedResult,
-};
-const PAUSE_NAMES = { none: 0, create: 1, fill: 2, all: 3 };
-export function parseKinds(text) {
-    return parseKindSet(text, "kinds", false);
-}
-function parseKindSet(text, key, allowNone) {
-    if (allowNone && text === "none") {
-        return 0n;
-    }
-    let mask = 0n;
-    for (const name of text.split(",")) {
-        const kind = KIND_NAMES[name];
-        if (kind === undefined) {
-            throw new UsageError(`--${key} takes ${allowNone ? "none or " : ""}a comma list of swap, limit, dutch, attested; got ${name}`);
-        }
-        mask |= kindBit(kind);
-    }
-    return mask;
-}
-export function parsePause(text, key) {
-    const flags = PAUSE_NAMES[text];
-    if (flags === undefined) {
-        throw new UsageError(`--${key} must be none, create, fill or all`);
-    }
-    return flags;
-}
-function parseBounded(text, key, max, min = 0) {
-    if (!/^\d+$/.test(text) || BigInt(text) > BigInt(max) || BigInt(text) < BigInt(min)) {
-        throw new UsageError(`--${key} must be an integer from ${min} to ${max}`);
-    }
-    return Number(text);
-}
-function parseKindFees(text) {
-    const bps = [0, 0, 0, 0];
-    let mask = 0;
-    if (text === "") {
-        return { mask, bps };
-    }
-    for (const pair of text.split(",")) {
-        const [name, value] = pair.split("=");
-        const kind = name === undefined ? undefined : KIND_NAMES[name];
-        if (kind === undefined || value === undefined) {
-            throw new UsageError(`--kind-fees takes name=bps pairs for swap, limit, dutch, attested; got ${pair}`);
-        }
-        if ((mask & (1 << kind)) !== 0) {
-            throw new UsageError(`--kind-fees names ${name} twice`);
-        }
-        mask |= 1 << kind;
-        bps[kind - 1] = parseBounded(value, "kind-fees", 0xffff);
-    }
-    return { mask, bps };
-}
-export const MAX_EVENT_LIMIT = 1_000;
-export function parseLimit(text) {
-    if (!/^\d+$/.test(text) || Number(text) < 1 || Number(text) > MAX_EVENT_LIMIT) {
-        throw new UsageError(`--limit must be an integer from 1 to ${MAX_EVENT_LIMIT}`);
-    }
-    return Number(text);
-}
-export function parseFeeBps(text) {
-    if (!/^\d+$/.test(text) || BigInt(text) > 65535n) {
-        throw new UsageError("--fee-bps must be an integer from 0 to 65535");
-    }
-    return Number(text);
-}
-const EXPIRY = ["expires-at", "expires-in"];
-const ORDER = [
-    "amount-in",
-    "min-out",
-    "make",
-    "take",
-    "start-out",
-    "end-out",
-    "start-at",
-    "end-at",
-    "min-result",
-    "max-result",
-    "attestor",
-];
-const MANDATE_ORDER = ORDER.filter((o) => o !== "min-result" && o !== "max-result" && o !== "attestor");
-export const MANDATE_USE_KINDS = "a mandate covers swap, limit and dutch orders; name one of those";
-export const ACCEPTS = {
-    setup: ["url", "keypair"],
-    balance: ["url", "keypair", "owner", "mints"],
-    pda: ["owner", "nonce"],
-    hash: ["artifact"],
-    show: ["url", "owner", "nonce"],
-    domain: ["url"],
-    mcp: [
-        "url",
-        "priority-fee",
-        "relayer",
-        "relay-max-lamports",
-        "relay-max-ttl",
-        "relay-per-hour",
-        "relay-hourly-lamports",
-        "relay-fee",
-        "agent",
-        "agent-hourly-lamports",
-        "agent-owners",
-        "wallet",
-        "wallet-per-trade",
-        "wallet-per-hour",
-    ],
-    quote: ["url", "owner", "nonce", "at"],
-    cancel: ["url", "priority-fee", "keypair", "nonce"],
-    expire: ["url", "priority-fee", "keypair", "owner", "nonce"],
-    close: ["url", "priority-fee", "keypair", "owner", "nonce"],
-    "advance-nonce": ["url", "priority-fee", "keypair", "base"],
-    "advance-epoch": ["url", "priority-fee", "keypair"],
-    "init-config": ["url", "priority-fee", "keypair", "authority", "yes", "guardian", "fee-recipient", "fee-bps", "kinds", "flags"],
-    "raise-pause": ["url", "priority-fee", "keypair", "authority", "yes", "flags"],
-    "set-economics": ["url", "priority-fee", "keypair", "authority", "yes", "bounty", "create-fee", "kind-fees", "partner-cut"],
-    "update-config": [
-        "url",
-        "priority-fee",
-        "keypair",
-        "authority",
-        "yes",
-        "guardian",
-        "fee-recipient",
-        "fee-bps",
-        "kinds",
-        "fill-disabled",
-    ],
-    "propose-admin": ["url", "priority-fee", "keypair", "authority", "yes", "new-admin"],
-    "accept-admin": ["url", "priority-fee", "keypair", "authority", "yes"],
-    solve: ["url", "priority-fee", "keypair", "jupiter", "issue", "jito", "tip", "min-profit", "max-fee-bps", "slippage-bps", "route-program", "lookup-table", "watch", "interval"],
-    "solver-table": ["url", "solver", "mints"],
-    "lower-pause": ["url", "priority-fee", "keypair", "authority", "yes", "flags"],
-    events: ["url", "limit", "follow", "interval"],
-    jobs: ["url", "attestor"],
-    deliver: ["url", "priority-fee", "keypair", "yes", "intent", "sha256", "work-url"],
-    deliveries: ["url", "attestor", "intent"],
-    judge: ["url", "priority-fee", "keypair", "yes", "owner", "nonce", "spec", "artifact", "run", "pay-to", "timeout", "verdict"],
-    crank: ["url", "priority-fee", "keypair", "dry-run", "fund-accounts"],
-    treasury: ["url", "priority-fee", "keypair", "yes", "mints", "create"],
-    create: [
-        "url",
-        "priority-fee",
-        "keypair",
-        "yes",
-        "nonce",
-        "input-mint",
-        "output-mint",
-        ...EXPIRY,
-        ...ORDER,
-        "partner",
-        "partner-bps",
-        "units",
-    ],
-    list: ["url", "keypair", "owner"],
-    mandate: [
-        "url",
-        "priority-fee",
-        "keypair",
-        "yes",
-        "owner",
-        "agent",
-        "id",
-        "input-mint",
-        "output-mint",
-        "kinds",
-        "per-intent",
-        "total",
-        "max-intents",
-        "max-ttl",
-        "valid-for",
-        "floor-out",
-        "floor-in",
-        "partner",
-        "partner-bps",
-        "agent-fee",
-        "nonce",
-        ...EXPIRY,
-        ...ORDER,
-        "units",
-    ],
-    approve: ["url", "priority-fee", "keypair", "yes", "mint", "amount", "units"],
-    "revoke-approval": ["url", "priority-fee", "keypair", "yes", "mint"],
-    signed: [
-        "url",
-        "keypair",
-        "yes",
-        "out",
-        "file",
-        "nonce",
-        "input-mint",
-        "output-mint",
-        "submit-within",
-        "relayer-fee",
-        ...EXPIRY,
-        ...ORDER,
-        "partner",
-        "partner-bps",
-        "units",
-    ],
-};
-export const SUB_ACCEPTS = {
-    mandate: {
-        grant: [
-            "url",
-            "priority-fee",
-            "keypair",
-            "yes",
-            "agent",
-            "id",
-            "input-mint",
-            "output-mint",
-            "kinds",
-            "per-intent",
-            "total",
-            "max-intents",
-            "max-ttl",
-            "valid-for",
-            "floor-out",
-            "floor-in",
-            "partner",
-            "partner-bps",
-            "agent-fee",
-            "units",
-        ],
-        show: ["url", "keypair", "agent", "id", "owner"],
-        revoke: ["url", "priority-fee", "keypair", "yes", "agent", "id"],
-        use: ["url", "priority-fee", "keypair", "yes", "owner", "id", "nonce", ...EXPIRY, ...MANDATE_ORDER, "units"],
-    },
-    signed: {
-        prepare: [
-            "url",
-            "keypair",
-            "yes",
-            "out",
-            "nonce",
-            "input-mint",
-            "output-mint",
-            "submit-within",
-            "relayer-fee",
-            ...EXPIRY,
-            ...ORDER,
-            "partner",
-            "partner-bps",
-            "units",
-        ],
-        submit: ["url", "keypair", "yes", "file"],
-    },
-};
-function noRepeats(argv) {
-    const seen = new Set();
-    for (const arg of argv) {
-        if (arg === "--") {
-            return;
-        }
-        if (!arg.startsWith("--")) {
-            continue;
-        }
-        const name = arg.slice(2).split("=")[0] ?? "";
-        if (seen.has(name)) {
-            throw new UsageError(`--${name} is given more than once`);
-        }
-        seen.add(name);
-    }
-}
-function onlyAccepted(verb, sub, values) {
-    const accepted = verb === undefined ? undefined : (SUB_ACCEPTS[verb]?.[sub ?? ""] ?? ACCEPTS[verb]);
-    const named = verb !== undefined && SUB_ACCEPTS[verb]?.[sub ?? ""] !== undefined ? `${verb} ${sub}` : verb;
-    if (accepted === undefined) {
-        return;
-    }
-    for (const [key, value] of Object.entries(values)) {
-        if (value !== undefined &&
-            !accepted.includes(key) &&
-            !GLOBAL_OPTIONS.includes(key)) {
-            throw new UsageError(`${named} does not take --${key}`);
-        }
-    }
-}
-function required(values, key) {
-    const value = values[key];
-    if (value === undefined) {
-        throw new UsageError(`missing --${key}`);
-    }
-    return value;
-}
-export function parseU64(text, key) {
-    if (!/^\d+$/.test(text) || BigInt(text) > U64_MAX) {
-        throw new UsageError(`--${key} must be an integer from 0 to ${U64_MAX}`);
-    }
-    return BigInt(text);
-}
-export function parseI64(text, key) {
-    if (!/^-?\d+$/.test(text) || BigInt(text) < I64_MIN || BigInt(text) > I64_MAX) {
-        throw new UsageError(`--${key} must be an integer from ${I64_MIN} to ${I64_MAX}`);
-    }
-    return BigInt(text);
-}
-function parseAddress(text, key) {
-    try {
-        return address(text);
-    }
-    catch {
-        throw new UsageError(`--${key} is not a base58 address`);
-    }
-}
-const u64 = (values, key) => parseU64(required(values, key), key);
-const key = (values, name) => parseAddress(required(values, name), name);
-function amountOf(values, name) {
-    const side = TOKEN_SIDES[name];
-    if (values.units === "raw" || side === undefined) {
-        return u64(values, name).toString();
-    }
-    const text = required(values, name);
-    if (!TOKEN_AMOUNT_PATTERN.test(text)) {
-        throw new UsageError(`--${name} must be a token amount like 12 or 0.5`);
-    }
-    return { tokens: text, side };
-}
-function unitsOf(values) {
-    if (values.units !== undefined && values.units !== "raw" && values.units !== "tokens") {
-        throw new UsageError("--units must be raw or tokens");
-    }
-}
-const timeOf = (values, name) => parseI64(required(values, name), name).toString();
-const ORDER_FIELDS = {
-    swap: ["amount-in", "min-out"],
-    limit: ["make", "take"],
-    dutch: ["amount-in", "start-out", "end-out", "start-at", "end-at"],
-    attested: ["amount-in", "min-result", "max-result", "attestor"],
-};
-export function order(kind, values) {
-    const fields = kind === undefined ? undefined : ORDER_FIELDS[kind];
-    if (fields === undefined) {
-        throw new UsageError("name the order kind: swap, limit, dutch or attested");
-    }
-    for (const name of ORDER) {
-        if (values[name] !== undefined && !fields.includes(name)) {
-            throw new UsageError(`a ${kind} order does not take --${name}`);
-        }
-    }
-    switch (kind) {
-        case "swap":
-            return { kind, amount_in: amountOf(values, "amount-in"), min_out: amountOf(values, "min-out") };
-        case "limit":
-            return { kind, make_amount: amountOf(values, "make"), take_amount: amountOf(values, "take") };
-        case "dutch":
-            return {
-                kind,
-                amount_in: amountOf(values, "amount-in"),
-                start_out: amountOf(values, "start-out"),
-                end_out: amountOf(values, "end-out"),
-                start_time: timeOf(values, "start-at"),
-                end_time: timeOf(values, "end-at"),
-            };
-        default:
-            return {
-                kind,
-                amount_in: amountOf(values, "amount-in"),
-                min_result: amountOf(values, "min-result"),
-                max_result: amountOf(values, "max-result"),
-                attestor: key(values, "attestor"),
-            };
-    }
-}
-export function expiry(values) {
-    if ((values["expires-at"] === undefined) === (values["expires-in"] === undefined)) {
-        throw new UsageError("give exactly one of --expires-at or --expires-in");
-    }
-    return values["expires-at"] === undefined
-        ? { expires_in: parseBounded(required(values, "expires-in"), "expires-in", MAX_EXPIRES_IN) }
-        : { expires_at: timeOf(values, "expires-at") };
-}
-function partner(values) {
-    if (values.partner === undefined && values["partner-bps"] === undefined) {
-        return {};
-    }
-    return {
-        partner: {
-            account: key(values, "partner"),
-            bps: parseBounded(required(values, "partner-bps"), "partner-bps", MAX_PARTNER_BPS),
-        },
-    };
-}
-const optionalField = (values, name, field, read) => values[name] === undefined ? {} : { [field]: read(values, name) };
-function terms(kind, values) {
-    return {
-        input_mint: key(values, "input-mint"),
-        output_mint: key(values, "output-mint"),
-        order: order(kind, values),
-        ...expiry(values),
-        ...optionalField(values, "nonce", "nonce", amountOf),
-        ...partner(values),
-    };
-}
-function grant(values) {
-    const kinds = required(values, "kinds").split(",");
-    for (const name of kinds) {
-        if (!MANDATE_KIND_NAMES.includes(name)) {
-            throw new UsageError(`--kinds takes a comma list of swap, limit, dutch; got ${name}`);
-        }
-    }
-    return {
-        agent: key(values, "agent"),
-        input_mint: key(values, "input-mint"),
-        output_mint: key(values, "output-mint"),
-        kinds,
-        per_intent: amountOf(values, "per-intent"),
-        total: amountOf(values, "total"),
-        max_intents: parseBounded(required(values, "max-intents"), "max-intents", 0xffff_ffff),
-        max_ttl: parseBounded(required(values, "max-ttl"), "max-ttl", MAX_EXPIRES_IN),
-        valid_for: parseBounded(required(values, "valid-for"), "valid-for", MAX_EXPIRES_IN),
-        floor: { out: amountOf(values, "floor-out"), in: amountOf(values, "floor-in") },
-        ...optionalField(values, "id", "id", amountOf),
-        ...partner(values),
-        ...optionalField(values, "agent-fee", "agent_fee", amountOf),
-    };
-}
-function mandate(sub, kind, remote, values) {
-    const flow = (name, input) => ({
-        name: "flow",
-        ...remote,
-        flow: name,
-        keypair: required(values, "keypair"),
-        yes: values.yes === true,
-        input,
-    });
-    const ref = () => ({ agent: key(values, "agent"), ...optionalField(values, "id", "id", amountOf) });
-    if (sub !== "use") {
-        noSub(kind);
-    }
-    switch (sub) {
-        case "grant":
-            return flow("mandate-grant", grant(values));
-        case "revoke":
-            return flow("mandate-revoke", ref());
-        case "show":
-            return {
-                name: "lookup",
-                ...remote,
-                lookup: "mandate-show",
-                keypair: values.keypair,
-                input: { ...ref(), ...optionalField(values, "owner", "owner", key) },
-            };
-        case "use":
-            if (kind === "attested") {
-                throw new UsageError(MANDATE_USE_KINDS);
-            }
-            return flow("mandate-use", {
-                owner: key(values, "owner"),
-                order: order(kind, values),
-                ...expiry(values),
-                ...optionalField(values, "id", "id", amountOf),
-                ...optionalField(values, "nonce", "nonce", amountOf),
-            });
-        default:
-            throw new UsageError("mandate needs grant, show, revoke or use");
-    }
-}
-function https(text, key) {
-    let parsed;
-    try {
-        parsed = new URL(text);
-    }
-    catch {
-        throw new UsageError(`--${key} is not a url`);
-    }
-    if (parsed.protocol !== "https:") {
-        throw new UsageError(`--${key} must be an https url`);
-    }
-    return text.replace(/\/+$/, "");
-}
-function relaySpec(values) {
-    const policy = [
-        values["relay-max-lamports"],
-        values["relay-max-ttl"],
-        values["relay-per-hour"],
-        values["relay-hourly-lamports"],
-        values["relay-fee"],
-    ];
-    if (values.relayer === undefined) {
-        if (policy.some((v) => v !== undefined)) {
-            throw new UsageError("the --relay-* limits need --relayer");
-        }
-        return undefined;
-    }
-    if (values["relay-fee"] === undefined) {
-        throw new UsageError(RELAY_NEEDS_FEES);
-    }
-    const maxTtl = parseBounded(values["relay-max-ttl"] ?? String(RELAY_DEFAULT_TTL), "relay-max-ttl", RELAY_MAX_TTL);
-    const perHour = parseBounded(values["relay-per-hour"] ?? String(RELAY_DEFAULT_PER_HOUR), "relay-per-hour", 3_600);
-    if (maxTtl < RELAY_MIN_TTL || perHour < 1) {
-        throw new UsageError(`--relay-max-ttl must be at least ${RELAY_MIN_TTL} and --relay-per-hour at least 1`);
-    }
-    return {
-        keypair: values.relayer,
-        maxLamports: values["relay-max-lamports"] === undefined ? 0n : u64(values, "relay-max-lamports"),
-        maxTtl: BigInt(maxTtl),
-        perHour,
-        hourlyLamports: values["relay-hourly-lamports"] === undefined
-            ? RELAY_DEFAULT_HOURLY_LAMPORTS
-            : u64(values, "relay-hourly-lamports"),
-        fees: mintAmounts(values["relay-fee"], "relay-fee"),
-    };
-}
-function mintAmounts(text, name) {
-    const amounts = new Map();
-    for (const entry of text === undefined ? [] : text.split(",")) {
-        const [mint, amount, ...rest] = entry.split("=");
-        if (mint === undefined || amount === undefined || rest.length > 0) {
-            throw new UsageError(`--${name} takes mint=amount pairs separated by commas`);
-        }
-        const key = parseAddress(mint.trim(), name);
-        if (amounts.has(key)) {
-            throw new UsageError(`--${name} names ${key} twice`);
-        }
-        amounts.set(key, parseU64(amount.trim(), name));
-    }
-    return amounts;
-}
-export const WALLET_LIMITS_NEED_WALLET = "--wallet-per-trade and --wallet-per-hour need --wallet";
-const wholeTokens = (key) => `--${key} takes token=amount pairs separated by commas, such as SOL=0.1,TEST=20`;
-function tokenAmounts(text, key, url) {
-    const amounts = new Map();
-    for (const entry of text === undefined ? [] : text.split(",")) {
-        const [name, amount, ...rest] = entry.split("=");
-        if (name === undefined || amount === undefined || rest.length > 0 || !TOKEN_AMOUNT_PATTERN.test(amount.trim())) {
-            throw new UsageError(wholeTokens(key));
-        }
-        const mint = tokenNamed(name.trim(), url);
-        if (mint instanceof Error) {
-            throw new UsageError(`--${key}: ${mint.message}`);
-        }
-        const parsed = parseAddress(mint, key);
-        if (amounts.has(parsed)) {
-            throw new UsageError(`--${key} names ${name.trim()} twice`);
-        }
-        amounts.set(parsed, amount.trim());
-    }
-    return amounts;
-}
-function walletLimits(values, url) {
-    if (values.wallet !== true) {
-        if (values["wallet-per-trade"] !== undefined || values["wallet-per-hour"] !== undefined) {
-            throw new UsageError(WALLET_LIMITS_NEED_WALLET);
-        }
-        return null;
-    }
-    return {
-        perTrade: tokenAmounts(values["wallet-per-trade"], "wallet-per-trade", url),
-        perHour: tokenAmounts(values["wallet-per-hour"], "wallet-per-hour", url),
-    };
-}
-function agentSpec(values) {
-    if (values.agent === undefined) {
-        if (values["agent-hourly-lamports"] !== undefined || values["agent-owners"] !== undefined) {
-            throw new UsageError("the --agent-* limits need --agent");
-        }
-        return undefined;
-    }
-    const owners = values["agent-owners"];
-    if (owners === undefined) {
-        throw new UsageError(AGENT_NEEDS_OWNERS);
-    }
-    return {
-        keypair: values.agent,
-        hourlyLamports: values["agent-hourly-lamports"] === undefined
-            ? AGENT_DEFAULT_HOURLY_LAMPORTS
-            : u64(values, "agent-hourly-lamports"),
-        owners: owners.split(",").map((o) => parseAddress(o.trim(), "agent-owners")),
-    };
-}
-export function parsePriority(text) {
-    if (text === undefined) {
-        return 0n;
-    }
-    if (text === "auto") {
-        return "auto";
-    }
-    const price = parseU64(text, "priority-fee");
-    if (price > MAX_PRIORITY_PRICE) {
-        throw new UsageError(`--priority-fee is micro-lamports per compute unit and at most ${MAX_PRIORITY_PRICE}; use auto for the recent market price`);
-    }
-    return price;
-}
-function authorityOf(values) {
-    if (values.keypair !== undefined && values.authority !== undefined) {
-        throw new UsageError("pass --keypair to sign and send, or --authority to print an unsigned transaction, not both");
-    }
-    if (values.authority !== undefined) {
-        if (values.yes === true) {
-            throw new UsageError("--yes signs and sends with --keypair; --authority only prints an unsigned transaction");
-        }
-        return { authority: key(values, "authority") };
-    }
-    return { keypair: required(values, "keypair"), yes: values.yes === true };
-}
-function configChange(values) {
-    const change = {
-        guardian: values.guardian === undefined ? undefined : key(values, "guardian"),
-        feeRecipient: values["fee-recipient"] === undefined ? undefined : key(values, "fee-recipient"),
-        feeBps: values["fee-bps"] === undefined ? undefined : parseFeeBps(values["fee-bps"]),
-        enabledKinds: values.kinds === undefined ? undefined : parseKinds(values.kinds),
-        fillDisabledKinds: values["fill-disabled"] === undefined ? undefined : parseKindSet(values["fill-disabled"], "fill-disabled", true),
-    };
-    if (Object.values(change).every((v) => v === undefined)) {
-        throw new UsageError("update-config needs at least one of --guardian, --fee-recipient, --fee-bps, --kinds, --fill-disabled");
-    }
-    return change;
-}
-const MINT_KEYS = ["input-mint", "output-mint", "mint"];
-function resolved(text, url) {
-    const mint = tokenNamed(text, url);
-    if (mint instanceof Error) {
-        throw new UsageError(mint.message);
-    }
-    return mint;
-}
-function named(values, url) {
-    for (const name of MINT_KEYS) {
-        const text = values[name];
-        if (text !== undefined) {
-            values[name] = resolved(text, url);
-        }
-    }
-    if (values.mints !== undefined) {
-        values.mints = values.mints
-            .split(",")
-            .map((m) => resolved(m.trim(), url))
-            .join(",");
-    }
-}
-function mintList(text) {
-    return addressList(text, "mints");
-}
-export const ISSUE_FORMAT = "--issue takes <input mint>:<output mint>=<out>/<in> entries separated by commas";
-export const ONE_MARKET = "solve needs exactly one of --jupiter or --issue";
-export const ISSUE_ALONE = "--issue mints the output itself, so --slippage-bps and --route-program do not apply";
-function issues(text) {
-    const routes = [];
-    for (const entry of text.split(",")) {
-        const match = /^([^:=/]+):([^:=/]+)=([^:=/]+)\/([^:=/]+)$/.exec(entry.trim());
-        if (match === null) {
-            throw new UsageError(ISSUE_FORMAT);
-        }
-        const [, input = "", output = "", out = "", per = ""] = match;
-        const route = {
-            inputMint: parseAddress(input.trim(), "issue"),
-            outputMint: parseAddress(output.trim(), "issue"),
-            out: parseU64(out.trim(), "issue"),
-            in: parseU64(per.trim(), "issue"),
-        };
-        if (route.out === 0n || route.in === 0n) {
-            throw new UsageError("--issue rates must be positive on both sides");
-        }
-        if (routes.some((r) => r.inputMint === route.inputMint && r.outputMint === route.outputMint)) {
-            throw new UsageError(`--issue names ${route.inputMint}:${route.outputMint} twice`);
-        }
-        routes.push(route);
-    }
-    return routes;
-}
-function market(values) {
-    if ((values.jupiter === undefined) === (values.issue === undefined)) {
-        throw new UsageError(ONE_MARKET);
-    }
-    if (values.issue === undefined) {
-        return { jupiter: https(required(values, "jupiter"), "jupiter"), issue: [] };
-    }
-    if (values["slippage-bps"] !== undefined || values["route-program"] !== undefined) {
-        throw new UsageError(ISSUE_ALONE);
-    }
-    return { jupiter: undefined, issue: issues(values.issue) };
-}
-function addressList(text, name) {
-    const items = [...new Set(text.split(",").map((m) => m.trim()))];
-    if (items.some((m) => m === "")) {
-        throw new UsageError(`--${name} takes a comma list of addresses`);
-    }
-    return items.map((m) => parseAddress(m, name));
-}
-export const TREASURY_CREATE_NEEDS_MINTS = "--create needs --mints naming the tokens to open treasury accounts for; anyone can open intents in any token, so the list must be yours";
-function treasury(remote, values) {
-    const create = values.create === true;
-    if (values.yes === true && !create) {
-        throw new UsageError("--yes only applies with --create");
-    }
-    if (create && values.mints === undefined) {
-        throw new UsageError(TREASURY_CREATE_NEEDS_MINTS);
-    }
-    return {
-        name: "treasury",
-        ...remote,
-        mints: values.mints === undefined ? null : mintList(values.mints),
-        create,
-        keypair: create ? required(values, "keypair") : values.keypair,
-        yes: values.yes === true,
-    };
-}
-export const SHA256_NEEDED = "--sha256 must be the work's sha256 as 64 hex digits";
-function sha256Of(text) {
-    if (!/^[0-9a-fA-F]{64}$/.test(text)) {
-        throw new UsageError(SHA256_NEEDED);
-    }
-    return text.toLowerCase();
-}
-function workUrlOf(text) {
-    if (!isMemoUrl(text)) {
-        throw new UsageError(`--work-url must be ${MEMO_URL_RULE}`);
-    }
-    return text;
-}
-export const JUDGE_TIMEOUT = 600;
-export const MAX_JUDGE_TIMEOUT = 86_400;
-export const RUN_NEEDED = "--run must name the command that checks the artifact";
-function runOf(text) {
-    if (text.trim() === "") {
-        throw new UsageError(RUN_NEEDED);
-    }
-    return text;
-}
-function noSub(sub) {
-    if (sub !== undefined) {
-        throw new UsageError(`unexpected argument ${sub}`);
-    }
-}
 export function clusterUrl(text) {
     return CLUSTERS[text] ?? text;
 }
-export function outputOf(argv) {
-    const at = argv.lastIndexOf("--output");
-    const inline = argv.findLast((a) => a.startsWith("--output="));
-    const value = at >= 0 ? argv[at + 1] : inline?.slice("--output=".length);
-    if (value === undefined) {
-        return "json";
-    }
-    if (value !== "json" && value !== "text") {
-        throw new UsageError("--output must be json or text");
-    }
-    return value;
-}
 export const MAX_FOLLOW_INTERVAL = 3_600;
 export const WATCH_INTERVAL = 5;
-export const COMMANDS = "setup | balance | pda | domain | mcp | show config | show intent | quote | cancel | expire | close | advance-nonce | advance-epoch | create swap|limit|dutch|attested | list | mandate grant|show|revoke|use <kind> | approve | revoke-approval | signed prepare <kind>|submit | init-config | update-config | set-economics | propose-admin | accept-admin | solve | raise-pause | lower-pause | crank | treasury | solver-table | events | jobs | deliver | deliveries | judge | hash | version | help [command]";
-export const USAGE = `usage: ${COMMANDS}`;
-const MANDATE_ORDER_SHAPE = "(--amount-in --min-out | --make --take | --amount-in --start-out --end-out --start-at --end-at)";
-const ORDER_SHAPE = "(--amount-in --min-out | --make --take | --amount-in --start-out --end-out --start-at --end-at | --amount-in --min-result --max-result --attestor)";
-const PARTNER_SHAPE = "[--partner <address> --partner-bps <n>]";
-export const SHAPES = {
-    setup: "[--url <cluster>] [--keypair <file>]",
-    balance: "[--keypair <file> | --owner <address>] [--mints <mint,...>]",
-    pda: "--owner <address> --nonce <n>",
-    hash: "--artifact <file or directory>",
-    show: "config | intent --owner <address> --nonce <n>",
-    domain: "",
-    mcp: "[--wallet [--wallet-per-trade <token=amount,...>] [--wallet-per-hour <token=amount,...>]] [--relayer <keypair> --relay-fee <mint=amount,...> [--relay-max-lamports] [--relay-max-ttl] [--relay-per-hour] [--relay-hourly-lamports]] [--agent <keypair> --agent-owners <address,...> [--agent-hourly-lamports]]",
-    quote: "--owner <address> --nonce <n> [--at <unix>]",
-    cancel: "--keypair <file> --nonce <n>",
-    expire: "--keypair <file> --owner <address> --nonce <n>",
-    close: "--keypair <file> --owner <address> --nonce <n>",
-    "advance-nonce": "--keypair <file> --base <n>",
-    "advance-epoch": "--keypair <file>",
-    "init-config": "(--keypair <file> [--yes] | --authority <address>) --guardian --fee-recipient --fee-bps --kinds [--flags create|fill|all]",
-    "update-config": "(--keypair <file> [--yes] | --authority <address>) and any of --guardian --fee-recipient --fee-bps --kinds --fill-disabled",
-    "propose-admin": "(--keypair <file> [--yes] | --authority <address>) --new-admin <address>",
-    "accept-admin": "(--keypair <file> [--yes] | --authority <address>)",
-    "raise-pause": "(--keypair <file> [--yes] | --authority <address>) --flags create|fill|all",
-    "lower-pause": "(--keypair <file> [--yes] | --authority <address>) --flags create|fill|all",
-    "set-economics": "(--keypair <file> [--yes] | --authority <address>) --bounty --create-fee [--kind-fees] [--partner-cut]",
-    solve: "--keypair <file> (--jupiter <url> | --issue <input mint>:<output mint>=<out>/<in>,...) --min-profit <output mint=raw,...> [--priority-fee <micro-lamports|auto>] [--max-fee-bps <n>] [--slippage-bps <n>] [--jito <url> [--tip <lamports>]] [--route-program <program the aggregator swaps through>] [--lookup-table <address,...>] [--watch [--interval <seconds>]]",
-    "solver-table": "--solver <address> --mints <mint,...>",
-    crank: "--keypair <file> [--dry-run] [--fund-accounts]",
-    treasury: "[--mints <mint,...>] [--create --mints <mint,...> --keypair <payer file> [--yes]]",
-    events: "[--limit <n>] [--follow [--interval <seconds>]]",
-    jobs: "[--attestor <address>]",
-    deliver: "--keypair <worker file> --intent <address> --sha256 <64 hex> --work-url <https url> [--yes]",
-    deliveries: "--attestor <address> --intent <address>",
-    judge: "--keypair <judge file> --owner <address> --nonce <n> --spec <file> --artifact <file or directory> --run <command> [--pay-to <wallet>] [--timeout <seconds>] [--verdict <file>] [--yes]",
-    create: `swap|limit|dutch|attested --keypair <file> --input-mint --output-mint (--expires-at | --expires-in) ${ORDER_SHAPE} [--nonce <n>] ${PARTNER_SHAPE} [--units tokens|raw] [--yes]`,
-    list: "--owner <address> or --keypair <file>; --owner wins when both are given",
-    mandate: `grant --keypair <file> --agent --input-mint --output-mint --kinds --per-intent --total --max-intents --max-ttl --valid-for --floor-out --floor-in [--agent-fee] ${PARTNER_SHAPE} [--id] [--units tokens|raw] [--yes] | show --agent (--owner <address> | --keypair <file>) [--id] | revoke --keypair <file> --agent [--id] [--yes] | use swap|limit|dutch --keypair <file> --owner (--expires-at | --expires-in) ${MANDATE_ORDER_SHAPE} [--id] [--nonce <n>] [--units tokens|raw] [--yes]`,
-    approve: "--keypair <file> --mint <mint> --amount <amount> [--units tokens|raw] [--yes]",
-    "revoke-approval": "--keypair <file> --mint <mint> [--yes]",
-    signed: `prepare swap|limit|dutch|attested --keypair <file> --out <file> --input-mint --output-mint (--expires-at | --expires-in) ${ORDER_SHAPE} [--nonce <n>] [--submit-within <seconds>] [--relayer-fee] ${PARTNER_SHAPE} [--units tokens|raw] [--yes] | submit --keypair <relayer file> --file <file> [--yes]`,
-};
-export function usageOf(verb) {
-    const known = verb !== undefined && ACCEPTS[verb] !== undefined;
-    return {
-        usage: known ? `${verb} ${SHAPES[verb] ?? ""}`.trim() : COMMANDS,
-        options: known ? [...(ACCEPTS[verb] ?? []), ...GLOBAL_OPTIONS].map((o) => `--${o}`) : [],
-    };
-}
 export function parse(argv, env = {}) {
     noRepeats(argv);
     let parsed;
@@ -991,7 +90,10 @@ export function parse(argv, env = {}) {
             if (sub === "intent") {
                 return { name: "show-intent", ...remote, owner: key(values, "owner"), nonce: u64(values, "nonce") };
             }
-            throw new UsageError("show needs config or intent");
+            if (sub === "mint-cap") {
+                return { name: "show-mint-cap", ...remote, mint: key(values, "mint") };
+            }
+            throw new UsageError("show needs config, intent or mint-cap");
         case "setup":
             noSub(sub);
             return { name: "setup", ...remote, keypair: values.keypair };
@@ -1027,7 +129,14 @@ export function parse(argv, env = {}) {
             };
         case "cancel":
             noSub(sub);
-            return { name: "cancel", ...remote, keypair: required(values, "keypair"), nonce: u64(values, "nonce") };
+            return {
+                name: "cancel",
+                ...remote,
+                keypair: required(values, "keypair"),
+                yes: values.yes === true,
+                nonce: u64(values, "nonce"),
+                close: values.close === true,
+            };
         case "expire":
         case "close":
             noSub(sub);
@@ -1035,6 +144,7 @@ export function parse(argv, env = {}) {
                 name: verb,
                 ...remote,
                 keypair: required(values, "keypair"),
+                yes: values.yes === true,
                 owner: key(values, "owner"),
                 nonce: u64(values, "nonce"),
             };
@@ -1090,6 +200,9 @@ export function parse(argv, env = {}) {
             if (values.interval !== undefined && values.watch !== true) {
                 throw new UsageError("--interval needs --watch");
             }
+            if (remote.priority !== "auto" && remote.priority > AUTO_PRICE_CAP) {
+                throw new UsageError(solveFeeAboveCap);
+            }
             return {
                 name: "solve",
                 ...remote,
@@ -1097,8 +210,10 @@ export function parse(argv, env = {}) {
                 ...market(values),
                 jito: values.jito === undefined ? undefined : https(values.jito, "jito"),
                 tipLamports,
-                minProfit: mintAmounts(required(values, "min-profit"), "min-profit"),
+                minProfit: profitFloors(required(values, "min-profit")),
                 maxFeeBps: parseBounded(values["max-fee-bps"] ?? "100", "max-fee-bps", 200),
+                maxSolCost: values["max-sol-cost"] === undefined ? DEFAULT_MAX_SOL_COST : parseSolCost(values["max-sol-cost"]),
+                maxRent: values["max-rent"] === undefined ? DEFAULT_MAX_RENT : parseMaxRent(values["max-rent"]),
                 slippageBps: parseBounded(values["slippage-bps"] ?? "50", "slippage-bps", 10_000),
                 routeProgram: values["route-program"] === undefined ? undefined : parseAddress(values["route-program"], "route-program"),
                 lookupTables: values["lookup-table"] === undefined ? [] : addressList(values["lookup-table"], "lookup-table"),
@@ -1114,6 +229,31 @@ export function parse(argv, env = {}) {
         case "accept-admin":
             noSub(sub);
             return { name: "accept-admin", ...remote, by: authorityOf(values) };
+        case "set-mint-cap": {
+            noSub(sub);
+            const maxPerOrder = u64(values, "max-per-order");
+            const windowCap = u64(values, "window-cap");
+            if (maxPerOrder === 0n) {
+                throw new UsageError("--max-per-order must be above zero");
+            }
+            if (windowCap < maxPerOrder) {
+                throw new UsageError("--window-cap must be at least --max-per-order");
+            }
+            return {
+                name: "set-mint-cap",
+                ...remote,
+                by: authorityOf(values),
+                mint: key(values, "mint"),
+                maxPerOrder,
+                windowCap,
+                windowSecs: parseBounded(required(values, "window-secs"), "window-secs", 0xffff_ffff, MIN_CAP_WINDOW_SECS),
+            };
+        }
+        case "set-caps-required":
+            if (sub !== "on" && sub !== "off") {
+                throw new UsageError("set-caps-required needs on or off");
+            }
+            return { name: "set-caps-required", ...remote, by: authorityOf(values), required: sub === "on" };
         case "events":
             noSub(sub);
             if (values.follow === true) {
@@ -1143,13 +283,36 @@ export function parse(argv, env = {}) {
                 yes: values.yes === true,
                 intent: key(values, "intent"),
                 sha256: sha256Of(required(values, "sha256")),
-                workUrl: workUrlOf(required(values, "work-url")),
+                workUrl: memoUrlOf(required(values, "work-url"), "work-url"),
             };
         case "deliveries":
             noSub(sub);
-            return { name: "deliveries", ...remote, attestor: key(values, "attestor"), intent: key(values, "intent") };
-        case "judge":
+            return { name: "deliveries", ...remote, attestor: key(values, "attestor"), intent: key(values, "intent"), maxPages: maxPagesOf(values) };
+        case "receipt":
+            noSub(sub);
+            return {
+                name: "receipt",
+                ...remote,
+                owner: key(values, "owner"),
+                nonce: u64(values, "nonce"),
+                sha256: values.sha256 === undefined ? undefined : sha256Of(values.sha256),
+                ...releaseOption(values),
+            };
+        case "record-delivery":
+            noSub(sub);
+            return {
+                name: "record-delivery",
+                ...remote,
+                keypair: required(values, "keypair"),
+                yes: values.yes === true,
+                owner: key(values, "owner"),
+                nonce: u64(values, "nonce"),
+                sha256: sha256Of(required(values, "sha256")),
+                ...releaseOption(values),
+            };
+        case "judge": {
             noSub(sub);
+            const sandbox = sandboxOf(values);
             return {
                 name: "judge",
                 ...remote,
@@ -1159,14 +322,22 @@ export function parse(argv, env = {}) {
                 nonce: u64(values, "nonce"),
                 spec: required(values, "spec"),
                 artifact: required(values, "artifact"),
-                run: runOf(required(values, "run")),
+                run: sandbox.kind === "viper" ? undefined : runOf(required(values, "run")),
                 payTo: values["pay-to"] === undefined ? undefined : key(values, "pay-to"),
+                result: values.result === undefined ? undefined : u64(values, "result"),
                 timeout: parseBounded(values.timeout ?? String(JUDGE_TIMEOUT), "timeout", MAX_JUDGE_TIMEOUT, 1),
                 verdict: values.verdict,
+                maxPages: maxPagesOf(values),
+                check: values.check,
+                sandbox,
             };
+        }
         case "solver-table":
             noSub(sub);
             return { name: "solver-table", ...remote, solver: key(values, "solver"), mints: mintList(required(values, "mints")) };
+        case "monitor":
+            noSub(sub);
+            return monitorOf(remote, values);
         case "crank":
             noSub(sub);
             return {
@@ -1183,7 +354,7 @@ export function parse(argv, env = {}) {
                 flow: "create",
                 keypair: required(values, "keypair"),
                 yes: values.yes === true,
-                input: terms(sub, values),
+                input: createTerms(sub, values),
             };
         case "list":
             noSub(sub);
@@ -1199,6 +370,12 @@ export function parse(argv, env = {}) {
             };
         case "mandate":
             return mandate(sub, third, remote, values);
+        case "committee":
+            return committeeOf(sub, remote, values);
+        case "reputation":
+            return reputationOf(sub, remote, values);
+        case "feedback":
+            return feedbackOf(sub, remote, values);
         case "approve":
         case "revoke-approval":
             noSub(sub);