@candledottv/cli 0.11.16 → 0.11.17

package/README.md

@@ -1,6 +1,6 @@
 # @candledottv/cli
 
-The Candle CLI (current version 0.11.15): authorize a device from your browser, keep your own keys
+The Candle CLI (current version 0.11.17): authorize a device from your browser, keep your own keys
 in an encrypted vault on this machine, hand an agent a TEE wallet it can trade, and manage API
 keys, wallets, and setup health from the terminal. Zero runtime dependencies; the whole thing is
 one self-contained `dist/index.js` that runs under plain Node.
@@ -80,6 +80,7 @@ emergency procedure, rebinding, trusted wallets and API key access levels are al
 | `candle wallets` (alias `candle wallet`) | Shows the account's embedded (launch) wallets and any linked wallets, using the API key, with a `Signer` column saying whether this machine holds each linked wallet's signing key and a `Trusted` column saying whether it is yours (linked while signed in, or marked with `trust`). It links and revokes; it never generates or prints a key, which the vault now derives. |
 | `candle wallets import --chain solana\|evm`, `wallets revoke <wallet-id>` | Link a wallet you own (key from `--key-file` or a hidden prompt, sealed to Privy before it leaves the machine), or unlink one. |
 | `candle wallets trust\|untrust <label\|address\|id\|prefix*>...` | Mark linked wallets as yours so an agent's Read:Write:Transfer key can move funds into them, or clear the mark. Owner only, over the device token, with a typed confirm; a trailing `*`, as in `'tr-*'`, selects by prefix. |
+| `candle wallets allow-launch\|disallow-launch <label\|address\|id\|prefix*>...` | Let TEE wallets pay for a launch (`candle launch`), or stop them. Owner only, over the device token; the screen shows each wallet's label, address and bound key before a typed confirm. `disallow-launch --yes` skips the confirm. |
 | `candle wallets close-empty [--wallet embedded] [--keep <mint>]... [--yes]` | Closes the embedded wallet's empty token accounts and returns their rent to it, after a preview (`transfer:write`). |
 | `candle vault init\|status\|list\|new-key\|rename\|phrase show\|restore\|reconcile-exposure` | The encrypted local vault, `vault.enc` (Tier 1). `init` creates it with a passphrase factor and a 24-word recovery phrase (and no key), `new-key` derives a key inside it (`--count`, `--labels-from <file>` for many under one unlock), `list [filter] [--balances]` shows one line per key, `rename` changes a label only, `phrase show` displays the phrase on a terminal (never in `--json`, a log or a pipe), and `restore --phrase` rebuilds the derived keys on another machine with a new passphrase (`--count`, `--tee-count`, `--external-count`, `--evm-count` and `--evm-tee-count` for EVM keys and Hood TEE wallets, or a Solana gap scan with `--rpc-url`); a restored vault never allocates new keys. `reconcile-exposure` re-reads the account and adds exposure records, clearing nothing. No key ever leaves the vault to reach Candle. See [CLI custody](https://docs.candle.tv/developers/cli-custody). |
 | `candle vault factor list\|add passphrase\|add security-key\|add touch-id\|add passkey\|remove` (or `vault enroll <kind>`), `vault backup --to <path>\|icloud`, `vault verify-backup <path>` | What can open the vault, and proving a copy of it works: `backup` verifies the copy in full before reporting (a copy is sealed, keeping only the passphrase and security-key envelopes, unless it goes to a recognised local disk or removable drive, so a cloud folder and any path the CLI cannot place are both sealed unless `--accept-shared-domain` is passed), and `verify-backup` re-checks an existing one against this vault's key and address set. `add security-key` enrolls a FIDO2 security key (CTAP2 `hmac-secret`, user-verified with the key's PIN or biometric) through the bundled `candle-fido2` helper (`--install-helper` fetches and verifies this release's helper first); one key is not a recoverable factor, two keys are a pair, an enrolled key can authorize adding another, and the passphrase stays the recovery floor. `add touch-id` and `add passkey` are refused with `VAULT_FACTOR_UNSUPPORTED_ON_PLATFORM` until the Apple-signed helper ships. Every vault command then takes `--factor <id\|passphrase\|security-key>` to say which envelope opens it and `--device <id>` to name the key when several are attached. |
@@ -93,10 +94,10 @@ emergency procedure, rebinding, trusted wallets and API key access levels are al
 | `candle tee signer new --key <prefix\|label> [--out <pem>] [--force]` | On the trading machine, with that key's API key: generates the key's signer here and waits for the owner to approve it with `keys signer approve`. The key's wallets then trade from this machine. `--out` also writes a plaintext PEM for an SDK process. |
 | `candle tee rebind <wallet...> --to-key <prefix\|label>`, `candle tee rebinds [wallet]` | Move TEE wallets to another key on the same account (owner only, preview then `confirm`; funds and the relay signer do not move), and list the rebind history. |
 | `candle tee new\|enable` | The legacy path: `new` seals a fresh key in its own `tee-wallets.enc` and `enable <address> --vault <address>` delegates it with a pinned sweep vault. New setups use `vault promote`; `vault import-legacy --tee` migrates an existing store. |
-| `candle swap <from> <to> --amount <n>\|--percent <n> --wallet <tee> [--to <tee>] [--wait]` | Quote, confirm and swap through the TEE wallet's bound key; first buy after a launch is this command. The assets decide the chain (ETH, USDG or a 0x token is Hood; SOL, USDC, CNDL or a mint is Solana). SOL or USDC to ETH or USDG, or back, is a bridge through Relay into this key's own TEE wallet on the other chain (`--to` names it when there are several); `--wait` follows it for up to ten minutes. |
+| `candle swap <from> <to> --amount <n>\|--percent <n> --wallet <tee> [--to <tee>] [--wait]` | Quote, confirm and swap through the TEE wallet's bound key; the first buy after a launch is this command, unless `candle launch --buy` made it. The assets decide the chain (ETH, USDG or a 0x token is Hood; SOL, USDC, CNDL or a mint is Solana). SOL or USDC to ETH or USDG, or back, is a bridge through Relay into this key's own TEE wallet on the other chain (`--to` names it when there are several); `--wait` follows it for up to ten minutes. |
 | `candle swap status <id> [--kind trade\|swap\|launch] [--wait]` | Read an operation without resending it; `--wait` follows a bridge until it ends. |
 | `candle transfer --to <address\|wallet name\|vault> --asset <SOL\|USDC\|CNDL\|ETH\|USDG>\|--mint <mint>\|--token <0x...> --amount <decimal\|max> [--wallet <tee>] [--rpc-url <url>] [--yes]` | Move funds out of a TEE wallet through its bound Read:Write:Transfer key, to the wallet's own pinned vault (`--to vault`, any token, `max` allowed, one SOL transfer at most the server's backstop ceiling, 50 SOL by default) or to another of the account's wallets you linked while signed in or marked trusted (a base asset, counted against the key's caps, which must include a per-asset cap and a USD `--tx-limit`). The asset decides the chain: ETH, USDG or `--token` moves from a Hood TEE wallet. The destination and its kind are shown before you confirm; Candle builds, the relay signs, Candle broadcasts. |
-| `candle launch --name <name> --symbol <symbol> --image-url <url> --wallet <tee> [--quote-asset <asset>] [--dex-version v3\|v4]` | Create a token with no first buy; needs `launch:write`, operator-enabled `allowLaunch`, and the Pro or Max plan. The wallet decides the chain: a Hood TEE wallet launches on Hood and needs `--dex-version`. `--quote-asset` is sol, usdc or cndl on Solana, eth or usdg on Hood. |
+| `candle launch --name <name> --symbol <symbol> --image-url <url> --wallet <tee> [--buy <amount>] [--quote-asset <asset>] [--dex-version v3\|v4]` | Create a token from a TEE wallet. Without `--buy` it makes no first buy. `--buy <amount>` adds one from the same wallet, in whole units of the quote asset, reserved against the key's spend window before signing: in the launch transaction on Solana, as a last leg on Hood. It needs the server's `TEE_LAUNCH_BUYS_ENABLED`, which is off by default; while it is off Candle refuses the buy and nothing is built. Needs `launch:write`, `allowLaunch` turned on for the wallet by the account owner, and the Pro or Max plan. On Free, launch from the embedded wallet instead, with an optional dev buy (same transaction on Solana; best-effort follow-up on Hood): the MCP tool `candle_launch_and_seed` or the SDK's `launch()`. The wallet decides the chain: a Hood TEE wallet launches on Hood and needs `--dex-version`. `--quote-asset` is sol, usdc or cndl on Solana, eth or usdg on Hood. |
 | `candle pnl [--profile <name>]` | P&L: realized net, fees, unrealized and total, then open positions, the same figures the console shows. Without `--profile`, the account's books (every profile, the web app and the CLI, one ledger; needs the Read scope), with a By agent table (each key, then Manual, then the account total). With `--profile <name>`, that profile's key's share of the same P&L: realized on its sales and the open positions that belong to it, with a row per wallet that sums to the total. Each wallet is its own average-cost pool, and a recorded move between the account's wallets carries its cost. Both show a Solana block, a Hood block, then the combined figure, the closed positions as money made, minus money lost, plus partial sells, and a `CHAIN` column (and `WALLET`, where the API names it) on positions. Unpriced positions are never valued at zero; dust (worth under one cent) is marked and still counted. A bridge between Solana and Hood is not a trade, and bridge and Relay costs are not netted. DAMM v2 LP positions are included: realized (withdrawals against the cost basis at the add, plus claimed fees), unrealized (open positions at their share of the pool plus unclaimed fees, against that basis) and vs holding (what the deposited tokens would be worth held); `Total` stays the console's token figure and `Total with LP` covers tokens and LP. |
 | `candle portfolio [<filter>] [--chain solana\|hood] [--rpc-url <url>] [--evm-rpc-url <url>]` | Vault, TEE and embedded wallets on Solana and Hood in one table with chain, amount, price and value, subtotals per group and per chain, and a total. Solana vault and external balances are read over your own Solana RPC; Candle is sent only the mints, for prices. EVM vault keys are read over your own Hood RPC (`--evm-rpc-url`, else `CANDLE_EVM_RPC_URL`, else the built-in Hood RPC) for ETH and USDG only, priced by asset, never by address; an RPC on another chain is refused. An unpriced Hood token shows why (`no-market-row`, `stale-mark`, ...). `--chain` shows one chain. Each TEE wallet's DAMM v2 LP positions follow the tokens, valued by Candle at the same marks, and count in the total; one whose pool could not be read is shown as not read and the total says it is partial. |
 | `candle plans` | The plans the API serves (`GET /api/v1/agent/plans`): each plan's monthly price, agent trade fee, Hyperliquid perps builder fee, the limits a new key gets, and one row per capability (buying and selling tokens not launched on Candle, self-launch, atomic launch, linked wallets, perps, limit orders). Every number is the server's; the CLI bundles none. Needs no key and sends none. `--json` is the server's body. Your own plan is `candle doctor`'s Plan row. |
@@ -408,13 +409,19 @@ Before signing, the command displays venue, price impact, tier fee, minimum rece
 all returned token warnings. Missing price impact is explicitly **unavailable**, never zero.
 `--yes` skips the ordinary prompt but still prints warnings. With `--json`, stdout is one
 JSON result containing the quote; the preview and operation id go to stderr. Launch creation
-has no price impact or token receipt, shows its maximum SOL debit, and makes no first buy.
-Use a separate swap for that buy.
-
-Swaps require `swap:write`. Launch requires `launch:write` **and** operator-enabled
-`allowLaunch` on the wallet. The operator sets or clears it through the shipped
-`PUT /api/v1/agent/wallets/<id>/capabilities` endpoint with device/session authentication and
-`{"capability":"allowLaunch","enabled":true}`. An agent key cannot grant itself this permission.
+has no price impact or token receipt and shows its maximum SOL debit. Without `--buy` it makes
+no first buy; use a separate swap for that buy. With `--buy <amount>` (whole units of the quote
+asset, as `--amount` is for a swap) the same wallet buys at launch: in the launch transaction on
+Solana, as a last leg after the curve and the fee on Hood. Candle reserves the buy against the
+key's spend window before anything is signed. `--buy` needs the server's
+`TEE_LAUNCH_BUYS_ENABLED=1`, which is off by default; while it is off Candle refuses the buy
+(`VALIDATION_FAILED` on `buyAmount`) and nothing is built or signed.
+
+Swaps require `swap:write`. Launch requires `launch:write` **and** `allowLaunch` on the
+wallet, which is off by default. The account owner (not Candle, and not the agent) sets it with
+`candle wallets allow-launch <wallet>` and clears it with `candle wallets disallow-launch <wallet>`,
+over the device token from `candle auth login` (the same endpoint, `PUT /api/v1/agent/wallets/<id>/capabilities`,
+takes a device token or a web session). An agent key cannot grant itself this permission.
 
 For scripts, always supply a stable `--client-trade-id` for each intention. Otherwise the CLI
 generates and prints one. Reusing an existing id reads its status instead of rebuilding.

package/dist/index.js

@@ -14506,8 +14506,29 @@ async function request(ctx, key, path, body) {
     fetch: ctx.deps.fetch,
     env: ctx.deps.env
   });
-  if (!result.ok)
-    throw new TradingError(result.code ?? "REQUEST_FAILED", result.message);
+  if (!result.ok) {
+    const raw = result.raw;
+    const error = raw?.error;
+    const details = {};
+    for (const field of [
+      "field",
+      "stage",
+      "signature",
+      "leg",
+      "legs",
+      "hashes",
+      "retryable",
+      "evidenceStored",
+      "terminal"
+    ]) {
+      if (error?.[field] !== undefined && (field === "field" || path === "/api/v1/agent/swap/submit"))
+        details[field] = error[field];
+    }
+    throw new TradingError(result.code ?? "REQUEST_FAILED", result.message, {
+      ...Object.keys(details).length ? { details } : {},
+      ...path === "/api/v1/agent/swap/submit" && error?.stage === "unconfirmed" ? { exitCode: 3 } : {}
+    });
+  }
   if (!result.body || typeof result.body !== "object")
     throw new TradingError("INVALID_RESPONSE", "Candle returned an invalid response.");
   return result.body;
@@ -14553,7 +14574,7 @@ async function completeTradingWallet(ctx, row, appId, scope, chain2 = "solana",
   if (!row.active)
     throw new TradingError("TEE_WALLET_INACTIVE", `The payer must be a verified-active ${chainName(chain2)} TEE wallet.`);
   if (scope === "launch:write" && row.allowLaunch !== true)
-    throw new TradingError("LAUNCH_NOT_ALLOWED", `The operator must enable allowLaunch for wallet ${row.id} through PUT /api/v1/agent/wallets/${row.id}/capabilities using device/session authentication.`);
+    throw new TradingError("LAUNCH_NOT_ALLOWED", `The account owner must turn on allowLaunch for wallet ${row.id}: run candle wallets allow-launch ${row.id} on a profile signed in with candle auth login. An agent key cannot.`);
   if (!appId || !row.privyWalletId)
     throw new TradingError("SIGNER_UNAVAILABLE", "The server did not return its relay public identifiers.");
   const signer = await localSignerFor(ctx.deps, row.id, row.signerQuorumId);
@@ -30311,6 +30332,8 @@ function tradingFailure(ctx, error, id) {
     writeUsageFailure(ctx.deps, error.message, ctx.json);
     return 2;
   }
+  if (error instanceof TradingError && error.details)
+    describeSwapEvidence(ctx, error.details, error.details.terminal === true);
   writeLocalFailure(ctx.deps, {
     code: error instanceof TradingError ? error.code : "TRADING_FAILED",
     message: `${error instanceof Error ? describeRpcFailure(error) : "Trading failed."}${id ? ` Operation ${id}; use candle swap status ${id} before another attempt.` : ""}`,
@@ -30335,7 +30358,31 @@ async function tradingRead(ctx, client, read) {
     throw error;
   }
 }
+async function requestSwapBuild(ctx, key, body) {
+  try {
+    return await request(ctx, key, "/api/v1/agent/swap/build", body);
+  } catch (error) {
+    if (body.payer?.type === "main" && error instanceof TradingError && error.code === "VALIDATION_FAILED" && error.details?.field === "payer") {
+      throw new TradingError("EMBEDDED_PAYER_UNSUPPORTED", "This Candle deployment cannot hold an embedded-wallet swap back for confirmation. Nothing was built. Name a TEE wallet with --wallet, or point at a deployment that supports embedded swap builds.");
+    }
+    throw error;
+  }
+}
+function describeSwapEvidence(ctx, details, terminal) {
+  if (details.stage === "not_broadcast" && terminal)
+    ctx.deps.stderr.write(`Nothing was sent. This swap job is terminal; retry with a new id.
+`);
+  if (details.stage === "unconfirmed") {
+    const hashes = Array.isArray(details.hashes) ? details.hashes : typeof details.signature === "string" ? [details.signature] : [];
+    ctx.deps.stderr.write(`Swap outcome needs verification${details.leg !== undefined ? ` (leg ${safeText(String(details.leg))})` : ""}. Known hashes: ${hashes.length ? hashes.map((hash) => safeText(String(hash))).join(", ") : "unknown"}. Do not automatically retry or use a new id.
+`);
+  }
+}
 function printTradingResult(ctx, result) {
+  if (result.kind === "swap" && result.job && typeof result.job === "object") {
+    const job = result.job;
+    describeSwapEvidence(ctx, job, job.status === "failed");
+  }
   ctx.deps.stdout.write(ctx.json ? `${JSON.stringify(result)}
 ` : `${JSON.stringify(result, null, 2)}
 `);
@@ -30533,8 +30580,6 @@ async function swap(args, ctx) {
     if (prior)
       return printTradingResult(ctx, prior);
     const payerWallet = await tradingPayer(ctx, key, flags["--wallet"]);
-    if (payerWallet.kind === "embedded" && kind === "swap")
-      throw new TradingError("PAIR_UNSUPPORTED", "The embedded wallet cannot swap between base assets from this command yet: that rail executes in one call, so there would be nothing to confirm. Trade a token with it, or name a TEE wallet for a base pair.");
     const wallet = payerWallet.kind === "tee" ? payerWallet.wallet : { address: payerWallet.address };
     const solana = lazySolanaClient(ctx, flags["--rpc-url"]);
     const decimals = await decimalsFor(ctx, from, solana);
@@ -30560,14 +30605,14 @@ async function swap(args, ctx) {
       amountRaw = rawAmount(flags["--amount"], decimals);
     if (BigInt(amountRaw) > BigInt(Number.MAX_SAFE_INTEGER))
       throw new TradingError("INVALID_AMOUNT", "Amount exceeds the venue's exact integer range.");
-    if (payerWallet.kind === "embedded")
+    if (payerWallet.kind === "embedded" && kind === "trade")
       await assertDeferredExecuteSupported(ctx, key, id);
     if (!await claimOperation(ctx, key, id, kind))
       throw new TradingError("OPERATION_ALREADY_STARTED", "This machine already started this id; no write was resent.");
     ctx.deps.stderr.write(`Operation: ${id}
 `);
     const payer = payerWallet.kind === "tee" ? { type: "linked", linkedWalletId: payerWallet.wallet.id } : { type: "main" };
-    const built = kind === "swap" ? await request(ctx, key, "/api/v1/agent/swap/build", {
+    const built = kind === "swap" ? await requestSwapBuild(ctx, key, {
       clientTradeId: id,
       from,
       to,
@@ -30589,7 +30634,7 @@ async function swap(args, ctx) {
       return printTradingResult(ctx, { ...built, clientTradeId: id, kind });
     const data = swapBuildSchema.parse(kind === "swap" ? built.payload : built);
     if (kind === "swap" && (data.venue !== "jupiter" || data.recipient !== wallet.address))
-      throw new TradingError("INVALID_RESPONSE", "A TEE base swap must use Jupiter and return to its payer.");
+      throw new TradingError("INVALID_RESPONSE", "A base swap must use Jupiter and return to its payer.");
     if (kind === "trade" && (built.chain !== "solana" || built.walletAddress !== wallet.address))
       throw new TradingError("INVALID_RESPONSE", "The token build does not name the requested Solana payer.");
     const artifacts = kind === "swap" ? { ...data, transactionBase64: undefined, quoteSource: undefined, quoteAsset: undefined } : data.artifacts;
@@ -30616,9 +30661,11 @@ async function swap(args, ctx) {
     if (!Number.isFinite(data.expiresAt) || data.expiresAt <= ctx.deps.now())
       throw new TradingError("QUOTE_EXPIRED", "The quote expired before signing. Start a new intention with a new id.");
     if (payerWallet.kind === "embedded") {
-      const executed = await request(ctx, key, "/api/v1/trade/agent/execute", { clientTradeId: id });
+      const executed = kind === "swap" ? await request(ctx, key, "/api/v1/agent/swap/submit", { clientTradeId: id, swapId: data.swapId }) : await request(ctx, key, "/api/v1/trade/agent/execute", { clientTradeId: id });
+      const settled2 = kind === "swap" ? reportSettlement(ctx, executed.payload?.settlement, { asset: to, decimals: outDecimals }, id) : {};
       return printTradingResult(ctx, {
         ...executed,
+        ...settled2,
         clientTradeId: id,
         kind,
         quote,
@@ -30728,8 +30775,6 @@ async function hoodSwap(ctx, args) {
   if (prior)
     return printTradingResult(ctx, prior);
   const payer = await tradingPayer(ctx, key, flags["--wallet"], "swap:write", "hood");
-  if (payer.kind === "embedded" && kind === "swap")
-    throw new TradingError("PAIR_UNSUPPORTED", "The embedded wallet cannot swap ETH and USDG from this command: that rail executes in one call, so there would be nothing to confirm. Trade a token with it, or name a Hood TEE wallet.");
   const payerAddress = payer.kind === "tee" ? payer.wallet.address : payer.address;
   const rpc = lazyEvmRpc(ctx, flags["--rpc-url"]);
   const decimals = await hoodDecimals(from, rpc);
@@ -30742,7 +30787,7 @@ async function hoodSwap(ctx, args) {
       throw new TradingError("INVALID_AMOUNT", "The selected percentage rounds to zero raw units.");
   } else
     amountRaw = rawAmount(flags["--amount"], decimals);
-  if (payer.kind === "embedded")
+  if (payer.kind === "embedded" && kind === "trade")
     await assertDeferredExecuteSupported(ctx, key, id);
   if (!await claimOperation(ctx, key, id, kind))
     throw new TradingError("OPERATION_ALREADY_STARTED", "This machine already started this id; no write was resent.");
@@ -30751,7 +30796,7 @@ async function hoodSwap(ctx, args) {
   const payerBody = payer.kind === "tee" ? { type: "linked", linkedWalletId: payer.wallet.id } : { type: "main" };
   const base = from.base ?? to.base;
   const token = from.base ? to.asset : from.asset;
-  const built = kind === "swap" ? await request(ctx, key, "/api/v1/agent/swap/build", {
+  const built = kind === "swap" ? await requestSwapBuild(ctx, key, {
     clientTradeId: id,
     from: from.asset,
     to: to.asset,
@@ -30825,8 +30870,16 @@ async function hoodSwap(ctx, args) {
   if (!Number.isFinite(data.expiresAt) || data.expiresAt <= ctx.deps.now())
     throw new TradingError("QUOTE_EXPIRED", "The quote expired before signing. Start a new intention with a new id.");
   if (payer.kind === "embedded") {
-    const executed = await request(ctx, key, "/api/v1/trade/agent/execute", { clientTradeId: id });
-    return printTradingResult(ctx, { ...executed, clientTradeId: id, kind, quote, wallet: safeText(payerAddress) });
+    const executed = kind === "swap" ? await request(ctx, key, "/api/v1/agent/swap/submit", { clientTradeId: id, swapId: data.swapId }) : await request(ctx, key, "/api/v1/trade/agent/execute", { clientTradeId: id });
+    const settled2 = kind === "swap" ? reportSettlement(ctx, executed.payload?.settlement, { asset: to.asset, decimals: outDecimals }, id) : {};
+    return printTradingResult(ctx, {
+      ...executed,
+      ...settled2,
+      clientTradeId: id,
+      kind,
+      quote,
+      wallet: safeText(payerAddress)
+    });
   }
   const wallet = payer.wallet;
   if (wallet.chain !== "evm" || !sequenced)
@@ -30935,7 +30988,7 @@ async function bridgeSwap(ctx, args) {
     throw new TradingError("OPERATION_ALREADY_STARTED", "This machine already started this id; no write was resent.");
   ctx.deps.stderr.write(`Operation: ${id}
 `);
-  const built = await request(ctx, key, "/api/v1/agent/swap/build", {
+  const built = await requestSwapBuild(ctx, key, {
     clientTradeId: id,
     from,
     to,
@@ -50758,7 +50811,7 @@ var init_convert = __esm(() => {
 });
 
 // ../mcp/src/version.ts
-var SERVER_VERSION = "0.10.6";
+var SERVER_VERSION = "0.10.7";
 
 // ../mcp/src/update-notice.ts
 function newer(a, b) {
@@ -52063,7 +52116,7 @@ function planTableMarkdown(table) {
   return [line(headers2), line(headers2.map(() => "---")), ...rows.map(line)].join(`
 `);
 }
-var PLAN_CAPABILITY_NOTE2 = "A capability marked yes is what the plan allows. It is subject to the deployment's own switches (perps and own-wallet bridges each have one) and to the wallet, scopes and setup the feature needs.", PLAN_CAPABILITY_LABELS2, PLAN_LABELS2;
+var PLAN_CAPABILITY_NOTE2 = "A capability marked yes is what the plan allows. It is subject to the deployment's own switches (perps and own-wallet bridges each have one) and to the wallet, scopes and setup the feature needs. Every plan can launch a token from its embedded wallet, with an optional dev buy (same transaction on Solana; best-effort follow-up on Hood), through the headless launch; the two launch rows are additional routes, not the only ones.", PLAN_CAPABILITY_LABELS2, PLAN_LABELS2;
 var init_plans = __esm(() => {
   PLAN_CAPABILITY_LABELS2 = {
     tradeCandleTokens: "Trade Candle-launched tokens",
@@ -52072,8 +52125,8 @@ var init_plans = __esm(() => {
     sellExternalTokens: "Sell tokens not launched on Candle",
     buyExternalTokens: "Buy tokens not launched on Candle",
     hyperliquidPerps: "Hyperliquid perps (when enabled)",
-    selfLaunch: "Self-launch from a linked wallet",
-    atomicLaunch: "Atomic launch with first buys",
+    selfLaunch: "Launch from a linked or TEE wallet (self-signed)",
+    atomicLaunch: "Atomic launch: launch + 1–4 first buys in one bundle",
     createLinkedWallets: "Create linked wallets",
     importLinkedWallets: "Import linked wallets",
     limitOrders: "Limit orders",
@@ -52288,7 +52341,7 @@ function registerTools(server, env = process.env) {
   };
   register("candle_launch_token", {
     title: "Launch a token on Candle",
-    description: "Launch a new token via the Candle headless launch API. Set dryRun: true to validate without spending anything.",
+    description: "Launch a new token via the Candle headless launch API, from the account's embedded wallet. Works on every plan, Free included. Set dryRun: true to validate without spending anything.",
     inputSchema: launchTokenShape
   }, async (args) => callAndRelay("candle_launch_token", args, cfg));
   register("candle_get_market", {
@@ -52454,7 +52507,7 @@ MARKET_NOT_FOUND means Candle has no market for that token and this could not ru
   });
   register("candle_launch_and_seed", {
     title: "Launch a token and seed it",
-    description: "Launch a new token with an optional dev-buy seed bundled into the launch itself, then " + "return the fresh market state and token links in one result. MOVES REAL FUNDS unless " + "dryRun. Seeds above the platform dev-buy ceiling are rejected (DEV_BUY_TOO_HIGH); " + "launch, then top up with candle_trade.",
+    description: "Launch a new token from the account's embedded wallet, with an optional dev-buy seed (in the " + "launch transaction on solana, a best-effort follow-up on hood). Works on every plan, Free included (this is not the atomic launch). Then " + "return the fresh market state and token links in one result. MOVES REAL FUNDS unless " + "dryRun. Seeds above the platform dev-buy ceiling are rejected (DEV_BUY_TOO_HIGH); " + "launch, then top up with candle_trade.",
     inputSchema: launchAndSeedShape
   }, async (args) => {
     const result = await executeLaunchAndSeed(args, cfg, fetch);
@@ -52631,7 +52684,7 @@ var init_tools = __esm(() => {
   launchAndSeedShape = {
     ...seedableLaunchShape,
     clientLaunchId: exports_external.string().optional().describe("Idempotency key. Auto-generated when omitted and echoed in the result."),
-    devBuy: exports_external.string().optional().describe('Seed buy in DECIMAL units of the quote asset this launch selects (e.g. "0.25" SOL, or ' + "ETH on hood), bundled into the launch transaction itself. Follows quoteAsset, which " + "defaults to sol on solana and eth on hood. Capped by the platform dev-buy ceiling; for " + "a larger seed, launch then follow with candle_trade.")
+    devBuy: exports_external.string().optional().describe('Seed buy in DECIMAL units of the quote asset this launch selects (e.g. "0.25" SOL, or ' + "ETH on hood), bundled into the launch transaction itself on solana and sent as a follow-up " + "transaction on hood. Paid from the account's embedded wallet. Follows quoteAsset, which " + "defaults to sol on solana and eth on hood. Capped by the platform dev-buy ceiling; for " + "a larger seed, launch then follow with candle_trade.")
   };
   transferShape = {
     chain: exports_external.enum(["solana", "hood"]).describe("Which chain the transfer executes on"),
@@ -52770,7 +52823,7 @@ init_render();
 init_secret_store();
 
 // src/version.ts
-var CLI_VERSION = "0.11.16";
+var CLI_VERSION = "0.11.17";
 
 // src/commands/auth.ts
 init_keys_embedded_wallet();
@@ -53282,7 +53335,7 @@ var HELP = {
   swap: {
     group: "Trade",
     summary: "Quote, confirm and swap on Solana or Hood, bridge between them; read an operation by id",
-    description: "Swaps run through a TEE wallet's bound key: the quote is shown and confirmed before anything is sent, and the first buy after a launch is this command rather than part of the launch. The assets decide the chain (ETH, USDG or a 0x token is Hood; SOL, USDC, CNDL or a mint is Solana) and a named wallet must be on it. A Hood TEE wallet signs one leg at a time: approve, Permit2, trade, then the fee, each only after the one before it landed. SOL or USDC to ETH or USDG, or back, is a bridge through Relay from a TEE wallet into this key's own TEE wallet on the other chain (--to names it when there are several); Candle charges no fee, the key needs a raw cap on the origin asset, and this machine checks Relay's deposit before it is signed. The bridge prints its deposit and returns while Relay fills; --wait follows it for up to ten minutes. While it is open, a sweep of either wallet refuses BRIDGE_IN_FLIGHT for two hours. Vault to vault: fund the Solana TEE wallet from the vault, bridge, then disable and sweep the Hood TEE wallet into its vault. Every plan can trade Candle-launched tokens and base assets, and sell a token it holds that was not launched on Candle; buying such a token needs Pro or Max (TIER_REQUIRED otherwise). Each trade pays the plan's agent fee on top; a base-pair swap or a bridge between this key's own wallets pays none. candle plans shows the fees in force.",
+    description: "Swaps run through a TEE wallet's bound key: the quote is shown and confirmed before anything is sent. The first buy after a launch is this command, unless the launch carried it with candle launch --buy. The assets decide the chain (ETH, USDG or a 0x token is Hood; SOL, USDC, CNDL or a mint is Solana) and a named wallet must be on it. A Hood TEE wallet signs one leg at a time: approve, Permit2, trade, then the fee, each only after the one before it landed. SOL or USDC to ETH or USDG, or back, is a bridge through Relay from a TEE wallet into this key's own TEE wallet on the other chain (--to names it when there are several); Candle charges no fee, the key needs a raw cap on the origin asset, and this machine checks Relay's deposit before it is signed. The bridge prints its deposit and returns while Relay fills; --wait follows it for up to ten minutes. While it is open, a sweep of either wallet refuses BRIDGE_IN_FLIGHT for two hours. Vault to vault: fund the Solana TEE wallet from the vault, bridge, then disable and sweep the Hood TEE wallet into its vault. Every plan can trade Candle-launched tokens and base assets, and sell a token it holds that was not launched on Candle; buying such a token needs Pro or Max (TIER_REQUIRED otherwise). Each trade pays the plan's agent fee on top; a base-pair swap or a bridge between this key's own wallets pays none. candle plans shows the fees in force.",
     usage: ["candle swap <from> <to> [flags]", "candle swap status <id>"],
     rows: [
       {
@@ -53440,10 +53493,10 @@ var HELP = {
   },
   launch: {
     group: "Trade",
-    summary: "Create a token on Solana or Hood (the first buy is a separate swap)",
-    description: "Creates a token with no first buy, so the launch and the position are two decisions rather than one. Needs the launch:write scope and an operator-enabled allowLaunch. The wallet decides the chain: a Hood TEE wallet launches on Hood, needs --dex-version, and signs one leg at a time (the curve, then the fee), each only after the one before it landed. Launching from a TEE wallet needs Pro or Max (TIER_REQUIRED otherwise; candle plans).",
+    summary: "Create a token on Solana or Hood, with an optional first buy",
+    description: "Creates a token from a TEE wallet. Without --buy it makes no first buy, so the launch and the position are two decisions, and the buy is a separate candle swap. --buy <amount> adds a first buy from the same wallet, in whole units of the quote asset (SOL, USDC or CNDL on Solana, ETH on Hood; not USDG), within the dev-buy ceilings: on Solana it rides in the launch transaction, and on Hood it is a last leg after the curve and the fee. Candle reserves the buy against the key's spend window before anything is signed. --buy needs a server with TEE_LAUNCH_BUYS_ENABLED on, which is off by default; while it is off Candle refuses the buy and nothing is built. Needs the launch:write scope and allowLaunch on the wallet, which only the account owner can turn on (candle wallets allow-launch <wallet>, over the device token; an agent key cannot). The wallet decides the chain: a Hood TEE wallet launches on Hood, needs --dex-version, and signs one leg at a time (the curve, then the fee, then the buy with --buy), each only after the one before it landed. Launching from a TEE wallet needs Pro or Max (TIER_REQUIRED otherwise; candle plans). Every plan, Free included, can launch from its embedded wallet with an optional dev buy (same transaction on Solana; best-effort follow-up on Hood), through the MCP tool candle_launch_and_seed or the SDK's launch(); this command does not use that path.",
     usage: [
-      "candle launch --name <name> --symbol <symbol> --image-url <url> --wallet <tee> [--quote-asset <asset>] [--dex-version v3|v4]"
+      "candle launch --name <name> --symbol <symbol> --image-url <url> --wallet <tee> [--buy <amount>] [--quote-asset <asset>] [--dex-version v3|v4]"
     ],
     rows: [],
     flags: [
@@ -53451,6 +53504,10 @@ var HELP = {
       { invocation: "--symbol <symbol>", description: "The token's ticker" },
       { invocation: "--image-url <url>", description: "The token image, already hosted" },
       { invocation: "--wallet <tee>", description: "The TEE wallet that creates it" },
+      {
+        invocation: "--buy <amount>",
+        description: "A first buy from the same wallet, in whole units of the quote asset; needs TEE_LAUNCH_BUYS_ENABLED on the server"
+      },
       { invocation: "--quote-asset <asset>", description: "sol, usdc or cndl on Solana; eth or usdg on Hood" },
       {
         invocation: "--dex-version v3|v4",
@@ -53459,7 +53516,8 @@ var HELP = {
     ],
     examples: [
       "candle launch --name Demo --symbol DEMO --image-url https://example.com/d.png --wallet AgentOne",
-      "candle launch --name Demo --symbol DEMO --image-url https://example.com/d.png --wallet HoodAgent --dex-version v4"
+      "candle launch --name Demo --symbol DEMO --image-url https://example.com/d.png --wallet HoodAgent --dex-version v4",
+      "candle launch --name Demo --symbol DEMO --image-url https://example.com/d.png --wallet AgentOne --buy 0.1"
     ],
     env: ENV_API
   },
@@ -53596,6 +53654,14 @@ var HELP = {
         invocation: "untrust <label|address|id|prefix*>... [--yes]",
         description: "Clear the mark; moving funds in needs the withdrawal allowlist again (owner only)"
       },
+      {
+        invocation: "allow-launch <label|address|id|prefix*>...",
+        description: "Let TEE wallets pay for a launch (candle launch), after a screen of label, address and bound key (owner only; typed confirm)"
+      },
+      {
+        invocation: "disallow-launch <label|address|id|prefix*>... [--yes]",
+        description: "Stop TEE wallets paying for a launch; trading is unchanged (owner only)"
+      },
       {
         invocation: "close-empty [--wallet embedded] [--keep <mint>]... [--client-trade-id <id>] [--yes]",
         description: "Close the embedded wallet's empty token accounts and return their rent to it, after a preview (transfer:write)"
@@ -53606,6 +53672,7 @@ var HELP = {
       "candle wallet import --chain solana --key-file ./signer.json",
       "candle wallet revoke wal_123",
       "candle wallet trust 'tr-*' 'dest-*'",
+      "candle wallet allow-launch launcher-1",
       "candle wallet close-empty --keep EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
     ],
     env: ENV_API
@@ -59851,7 +59918,7 @@ init_solana_lite();
 init_trading();
 init_swap();
 import { randomUUID as randomUUID2 } from "node:crypto";
-var USAGE2 = "Usage: candle launch --name <name> --symbol <symbol> --image-url <https-url> --wallet <tee> [--client-trade-id <id>] [--quote-asset sol|usdc|cndl|eth|usdg] [--dex-version v3|v4] [--mode <mode>] [--rpc-url <url>] [--yes]. A Hood TEE wallet launches on Hood and needs --dex-version.";
+var USAGE2 = "Usage: candle launch --name <name> --symbol <symbol> --image-url <https-url> --wallet <tee> [--buy <amount>] [--client-trade-id <id>] [--quote-asset sol|usdc|cndl|eth|usdg] [--dex-version v3|v4] [--mode <mode>] [--rpc-url <url>] [--yes]. A Hood TEE wallet launches on Hood and needs --dex-version.";
 var QUOTE_CHAIN = {
   sol: "solana",
   usdc: "solana",
@@ -59860,6 +59927,34 @@ var QUOTE_CHAIN = {
   usdg: "hood"
 };
 var HOOD_LAUNCH_LEGS = ["createCurve", "feeTransfer"];
+var HOOD_LAUNCH_BUY_LEGS = ["createCurve", "feeTransfer", "trade"];
+function launchBuy(flags, chain2) {
+  const amount = flags["--buy"];
+  if (amount === undefined)
+    return;
+  const quote = (flags["--quote-asset"] ?? (chain2 === "hood" ? "eth" : "sol")).toUpperCase();
+  const decimals = chain2 === "hood" ? HOOD_BASES[quote]?.decimals : BASES[quote]?.decimals;
+  if (decimals === undefined)
+    throw new TradingError("INVALID_AMOUNT", `--buy is in the launch's quote asset, and ${safeText(quote)} is not one on ${chainName(chain2)}. Nothing was built.`);
+  const raw = rawAmount(amount, decimals);
+  return { raw, display: `${decimalAmount(raw, decimals)} ${quote}` };
+}
+function buyRefusal(error) {
+  if (!(error instanceof TradingError) || error.code !== "VALIDATION_FAILED" || error.details?.field !== "buyAmount")
+    return error;
+  return new TradingError("VALIDATION_FAILED", `Candle refused the first buy on this TEE launch: ${safeText(error.message)}. A TEE wallet's launch takes --buy only where the server has TEE_LAUNCH_BUYS_ENABLED on, and it is off on this deployment. Nothing was built or signed.`, {
+    suggestion: "Launch without --buy under a new --client-trade-id, then make the first buy with candle swap once the token lands.",
+    details: error.details
+  });
+}
+function buyNotice(buy, chain2) {
+  if (!buy)
+    return `Launch creates the token only. Make the first buy with a separate candle swap. Price impact does not apply to creation.
+`;
+  return chain2 === "hood" ? `Launch creates the token, then spends ${buy.display} on a first buy on the new curve, as the last leg. Candle reserves the buy against this key's spend window before any leg is signed. If the buy leg never lands, the token exists with no first buy. Price impact does not apply to creation.
+` : `Launch creates the token and spends ${buy.display} on a first buy in the same transaction. Candle reserves the whole debit against this key's spend window before anything is signed. Price impact does not apply to creation.
+`;
+}
 function flagChain(flags) {
   const said = [];
   const named = walletNameChain(flags["--wallet"] ?? "");
@@ -59889,7 +59984,8 @@ async function launch(args, ctx) {
       "--rpc-url",
       "--quote-asset",
       "--mode",
-      "--dex-version"
+      "--dex-version",
+      "--buy"
     ],
     booleanFlags: ["--yes"]
   });
@@ -59904,6 +60000,8 @@ async function launch(args, ctx) {
     return 2;
   }
   try {
+    if (flags["--buy"] !== undefined)
+      rawAmount(flags["--buy"], 18);
     const hinted = flagChain(flags);
     if (hinted === "hood" && flags["--dex-version"] === undefined) {
       writeUsageFailure(ctx.deps, `A Hood launch needs --dex-version v3|v4. ${USAGE2}`, ctx.json);
@@ -59929,8 +60027,10 @@ async function launch(args, ctx) {
     if (wallet.chain === "evm") {
       if (flags["--dex-version"] === undefined)
         throw new TradingUsage(`${wallet.address} is a Hood TEE wallet, and a Hood launch needs --dex-version v3|v4.`);
-      return await hoodLaunch(ctx, key, { flags, id, wallet, yes: parsed.booleans.has("--yes") });
+      const buy2 = launchBuy(flags, "hood");
+      return await hoodLaunch(ctx, key, { flags, id, wallet, buy: buy2, yes: parsed.booleans.has("--yes") });
     }
+    const buy = launchBuy(flags, "solana");
     const solana = await tradingSolanaClient(ctx, flags["--rpc-url"]);
     if (!await claimOperation(ctx, key, id, "launch"))
       throw new TradingError("OPERATION_ALREADY_STARTED", "This machine already started this launch id; no write was resent.");
@@ -59939,7 +60039,7 @@ async function launch(args, ctx) {
     const built = launchBuildSchema.parse(await request(ctx, key, "/api/v1/launch/self/build", {
       clientLaunchId: id,
       chain: "solana",
-      buyAmount: 0,
+      buyAmount: buy ? buy.raw : 0,
       name: flags["--name"],
       symbol: flags["--symbol"],
       imageUrl: flags["--image-url"],
@@ -59947,21 +60047,22 @@ async function launch(args, ctx) {
       ...flags["--description"] ? { description: flags["--description"] } : {},
       ...flags["--quote-asset"] ? { quoteAsset: flags["--quote-asset"] } : {},
       ...flags["--mode"] ? { mode: flags["--mode"] } : {}
+    }).catch((error) => {
+      throw buyRefusal(error);
     }));
     if (!built.transaction || !/^\d+$/.test(built.maxDebitLamports ?? ""))
       throw new TradingError("INVALID_RESPONSE", "Candle did not return a launch transaction and maximum debit; nothing was signed.");
     const quote = {
-      intent: `Launch ${flags["--name"]} (${flags["--symbol"]})`,
+      intent: `Launch ${flags["--name"]} (${flags["--symbol"]})${buy ? ` with a first buy of ${buy.display}` : ""}`,
       wallet: wallet.address,
       venue: "curve launch",
       priceImpactPct: null,
       fee: built.fee ?? { bps: 0, feeRaw: "0" },
-      minimumReceived: "0 tokens (no first buy)",
+      minimumReceived: buy ? "not quoted (the first buy on the new curve)" : "0 tokens (no first buy)",
       maxDebitLamports: built.maxDebitLamports,
       tokenRisks: []
     };
-    ctx.deps.stderr.write(`Launch creates the token only. Make the first buy with a separate candle swap. Price impact does not apply to creation.
-`);
+    ctx.deps.stderr.write(buyNotice(buy, "solana"));
     if (!await confirmQuote(ctx, quote, parsed.booleans.has("--yes")))
       return printTradingResult(ctx, { success: true, status: "cancelled", clientTradeId: id, kind: "launch", quote });
     if (!Number.isFinite(built.expiresAt) || built.expiresAt <= ctx.deps.now())
@@ -59987,7 +60088,8 @@ async function launch(args, ctx) {
   }
 }
 async function hoodLaunch(ctx, key, args) {
-  const { flags, id, wallet } = args;
+  const { flags, id, wallet, buy } = args;
+  const allowedLegs = buy ? HOOD_LAUNCH_BUY_LEGS : HOOD_LAUNCH_LEGS;
   if (!await claimOperation(ctx, key, id, "launch"))
     throw new TradingError("OPERATION_ALREADY_STARTED", "This machine already started this launch id; no write was resent.");
   ctx.deps.stderr.write(`Operation: ${id}
@@ -59995,7 +60097,7 @@ async function hoodLaunch(ctx, key, args) {
   const built = await request(ctx, key, "/api/v1/launch/self/build", {
     clientLaunchId: id,
     chain: "hood",
-    buyAmount: 0,
+    buyAmount: buy ? buy.raw : 0,
     name: flags["--name"],
     symbol: flags["--symbol"],
     imageUrl: flags["--image-url"],
@@ -60004,6 +60106,8 @@ async function hoodLaunch(ctx, key, args) {
     ...flags["--description"] ? { description: flags["--description"] } : {},
     ...flags["--quote-asset"] ? { quoteAsset: flags["--quote-asset"].toLowerCase() } : {},
     ...flags["--mode"] ? { mode: flags["--mode"] } : {}
+  }).catch((error) => {
+    throw buyRefusal(error);
   });
   const parsed = sequencedSchema.safeParse(built);
   if (!parsed.success)
@@ -60012,26 +60116,25 @@ async function hoodLaunch(ctx, key, args) {
   const curve = typeof built.curveAddress === "string" ? checkEvmAddress(built.curveAddress) : undefined;
   if (built.chain !== "hood" || built.clientLaunchId !== id || typeof built.walletAddress !== "string" || !sameEvmAddress(built.walletAddress, wallet.address) || !curve?.ok)
     throw new TradingError("INVALID_RESPONSE", "The Hood launch build does not name this launch and payer; nothing was signed.");
-  if (first.legKind !== "createCurve" || first.plannedLegCount > HOOD_LAUNCH_LEGS.length)
+  if (first.legKind !== "createCurve" || first.plannedLegCount > allowedLegs.length || buy !== undefined && first.plannedLegCount < 2)
     throw new TradingError("INVALID_RESPONSE", `A Hood launch starts with its createCurve leg, and Candle offered ${safeText(first.legKind)} of ${first.plannedLegCount}; nothing was signed.`);
   const leg = first.nextLeg;
   const maxFee = BigInt(leg.maxFeePerGas);
   const reserve = sweepReserveFloor(maxFee);
   const quote = {
-    intent: `Launch ${flags["--name"]} (${flags["--symbol"]}) on Hood`,
+    intent: `Launch ${flags["--name"]} (${flags["--symbol"]}) on Hood${buy ? ` with a first buy of ${buy.display}` : ""}`,
     wallet: wallet.address,
     venue: "curve launch",
     priceImpactPct: null,
-    minimumReceived: "0 tokens (no first buy)",
+    minimumReceived: buy ? "not quoted (Candle's buy leg sets its floor on the new curve)" : "0 tokens (no first buy)",
     tokenRisks: [],
-    legs: first.plannedLegCount === 2 ? ["create curve", "fee"] : ["create curve"],
-    gas: `the createCurve leg up to ${formatUnits(BigInt(leg.gas) * maxFee, 18)} ETH (gas ${leg.gas} at ${formatUnits(maxFee, 9)} gwei)${first.plannedLegCount === 2 ? "; the fee leg is priced by Candle when it becomes next" : ""}`,
+    legs: hoodLaunchLegNames(first.plannedLegCount, buy !== undefined),
+    gas: `the createCurve leg up to ${formatUnits(BigInt(leg.gas) * maxFee, 18)} ETH (gas ${leg.gas} at ${formatUnits(maxFee, 9)} gwei)${hoodLaterLegsGas(first.plannedLegCount, buy !== undefined)}`,
     reserve: `at least ${formatUnits(reserve.wei, 18)} ETH stays in the wallet for a sweep home (${reserve.erc20Transfers} ERC-20 transfers and the final ETH transfer at twice the fee)`,
     curveAddress: curve.address,
     operationId: first.operationId
   };
-  ctx.deps.stderr.write(`Launch creates the token only. Make the first buy with a separate candle swap. Price impact does not apply to creation.
-`);
+  ctx.deps.stderr.write(buyNotice(buy, "hood"));
   if (!await confirmQuote(ctx, quote, args.yes)) {
     ctx.deps.stderr.write(`Nothing was signed. Operation ${first.operationId} holds this wallet until ${new Date(first.expiresAt).toISOString()}; a new Hood operation from it is refused as WALLET_BUSY until then.
 `);
@@ -60046,6 +60149,8 @@ async function hoodLaunch(ctx, key, args) {
       walletHeldUntil: first.expiresAt
     });
   }
+  const confirmedPlan = buy ? first.plannedLegCount === 3 ? ["createCurve", "feeTransfer", "trade"] : ["createCurve", "trade"] : undefined;
+  let position = 0;
   const run2 = await runSequencedLegs(ctx, key, {
     wallet,
     first,
@@ -60055,10 +60160,16 @@ async function hoodLaunch(ctx, key, args) {
     clientId: id,
     kind: "launch",
     primaryLeg: "createCurve",
-    allowedLegs: HOOD_LAUNCH_LEGS,
-    checkLeg: (kind, leg2) => kind !== "createCurve" || leg2.value === "0",
+    allowedLegs,
+    checkLeg: (kind, leg2) => {
+      if (confirmedPlan && confirmedPlan[position++] !== kind)
+        return false;
+      return kind === "createCurve" ? leg2.value === "0" : kind !== "trade" || buy !== undefined && leg2.value === buy.raw && sameEvmAddress(leg2.to, curve.address);
+    },
     onLanded: async () => {}
   });
+  if (confirmedPlan && run2.landed.map((done) => done.kind).join() !== confirmedPlan.join())
+    throw new TradingError("INVALID_RESPONSE", `Candle ended the launch before every confirmed leg landed (${confirmedPlan.join(", ")}).${run2.landed.length === 0 ? " No leg landed." : ` Landed: ${run2.landed.map((done) => `${done.kind} ${safeText(done.hash)}`).join(", ")}.`}`, { details: { operationId: first.operationId, landedLegs: run2.landed } });
   return printTradingResult(ctx, {
     ...run2.final,
     ...await recordLaunchedToken(ctx, wallet, run2.final),
@@ -60071,6 +60182,16 @@ async function hoodLaunch(ctx, key, args) {
     landedLegs: run2.landed
   });
 }
+function hoodLaterLegsGas(count, buys) {
+  if (count < 2)
+    return "";
+  return buys ? "; the later legs are priced by Candle when each becomes next" : "; the fee leg is priced by Candle when it becomes next";
+}
+function hoodLaunchLegNames(count, buys) {
+  if (!buys)
+    return count === 2 ? ["create curve", "fee"] : ["create curve"];
+  return count === 3 ? ["create curve", "fee", "first buy"] : ["create curve", "first buy"];
+}
 async function recordLaunchedToken(ctx, wallet, final) {
   const mint = typeof final.mint === "string" ? checkEvmAddress(final.mint) : undefined;
   if (!mint?.ok) {
@@ -61633,7 +61754,7 @@ async function perpsDeposit(args, ctx) {
 init_args();
 
 // src/plans.ts
-var PLAN_CAPABILITY_NOTE = "A capability marked yes is what the plan allows. It is subject to the deployment's own switches (perps and own-wallet bridges each have one) and to the wallet, scopes and setup the feature needs.";
+var PLAN_CAPABILITY_NOTE = "A capability marked yes is what the plan allows. It is subject to the deployment's own switches (perps and own-wallet bridges each have one) and to the wallet, scopes and setup the feature needs. Every plan can launch a token from its embedded wallet, with an optional dev buy (same transaction on Solana; best-effort follow-up on Hood), through the headless launch; the two launch rows are additional routes, not the only ones.";
 var PLAN_CAPABILITY_LABELS = {
   tradeCandleTokens: "Trade Candle-launched tokens",
   tradeBaseAssets: "Trade base assets",
@@ -61641,8 +61762,8 @@ var PLAN_CAPABILITY_LABELS = {
   sellExternalTokens: "Sell tokens not launched on Candle",
   buyExternalTokens: "Buy tokens not launched on Candle",
   hyperliquidPerps: "Hyperliquid perps (when enabled)",
-  selfLaunch: "Self-launch from a linked wallet",
-  atomicLaunch: "Atomic launch with first buys",
+  selfLaunch: "Launch from a linked or TEE wallet (self-signed)",
+  atomicLaunch: "Atomic launch: launch + 1–4 first buys in one bundle",
   createLinkedWallets: "Create linked wallets",
   importLinkedWallets: "Import linked wallets",
   limitOrders: "Limit orders",
@@ -72327,6 +72448,176 @@ function messageOf3(error) {
 // src/index.ts
 init_wallets();
 
+// src/commands/wallets-allow-launch.ts
+init_args();
+init_deps();
+init_profiles();
+init_render();
+init_promote_support();
+var PREVIEW_PATH = "/api/v1/agent/tee-wallets/allow-launch/preview";
+var capabilityPath = (id) => `/api/v1/agent/wallets/${encodeURIComponent(id)}/capabilities`;
+var USAGE_ALLOW = "Usage: candle wallets allow-launch <label|address|id|prefix*>... [--json]";
+var USAGE_DISALLOW = "Usage: candle wallets disallow-launch <label|address|id|prefix*>... [--yes] [--json]";
+var DEVICE_TOKEN_REQUIRED2 = {
+  code: "DEVICE_TOKEN_REQUIRED",
+  message: "Changing whether a TEE wallet may launch needs the device token, the owner's credential; an API key cannot do it.",
+  suggestion: "Run: candle auth login"
+};
+var nameOf = (row) => row.label ?? row.address;
+function allowLaunchTable(rows) {
+  return renderTable(["line", "label", "wallet", "address", "bound key"], rows.map((row, i) => [String(i + 1), row.label ?? "-", row.chain, row.address, row.boundKeyPrefix ?? "-"]));
+}
+function nothingToChangeLine(shown, enabled) {
+  const bits = [];
+  if (shown.unchanged.length === 1)
+    bits.push(`that wallet already has allowLaunch ${enabled ? "on" : "off"}`);
+  else if (shown.unchanged.length > 1) {
+    bits.push(`all ${shown.unchanged.length} wallets already have allowLaunch ${enabled ? "on" : "off"}`);
+  }
+  if (shown.notTee.length > 0) {
+    bits.push(`${shown.notTee.map(nameOf).join(", ")} ${shown.notTee.length === 1 ? "is" : "are"} not a TEE wallet`);
+  }
+  if (bits.length === 0)
+    return `Nothing to change.
+`;
+  return `Nothing to change: ${bits.join("; ")}.
+`;
+}
+function writeFailure2(ctx, result) {
+  const { deps, apiUrl, json } = ctx;
+  let code = result.code;
+  let message = result.message;
+  let suggestion;
+  if (result.status === 404) {
+    code = "ALLOW_LAUNCH_UNSUPPORTED";
+    message = "This Candle API does not offer allowLaunch on TEE wallets (an older API, or TEE launch is off); nothing changed.";
+  } else {
+    const error = result.raw?.error;
+    if (error?.reason === "ambiguous" && Array.isArray(error.matches)) {
+      const ids = error.matches.map((m) => String(m.id)).join(", ");
+      suggestion = `Name one of them by id or address: ${ids}`;
+    } else if (error?.reason === "not_found") {
+      suggestion = "Run: candle wallets, to see this account's linked wallets and their labels.";
+    }
+  }
+  const envelope = errorEnvelope({ ...result, code, message }, { apiUrl, authType: "device" });
+  if (json) {
+    deps.stdout.write(`${JSON.stringify({ ...envelope, ...suggestion ? { suggestion } : {} })}
+`);
+  } else {
+    deps.stderr.write(`${code ?? `HTTP ${result.status}`}: ${message}${suggestion ? ` ${suggestion}` : ""}
+`);
+  }
+  return 1;
+}
+async function setAllowLaunch(args, ctx, enabled) {
+  const { deps, apiUrl, json } = ctx;
+  const usage6 = enabled ? USAGE_ALLOW : USAGE_DISALLOW;
+  const command = enabled ? "wallets allow-launch" : "wallets disallow-launch";
+  const parsed = parseArgs(args, enabled ? {} : { booleanFlags: ["--yes"] });
+  if ("error" in parsed) {
+    writeUsageFailure(deps, parsed.error, json);
+    return 2;
+  }
+  if (parsed.positionals.length === 0) {
+    writeUsageFailure(deps, `Name at least one wallet. ${usage6}`, json);
+    return 2;
+  }
+  const skipConfirm = !enabled && parsed.booleans.has("--yes");
+  await printIdentity(ctx);
+  const deviceToken = await resolveDeviceToken(deps, ctx.profile);
+  if (!deviceToken) {
+    writeLocalFailure(deps, DEVICE_TOKEN_REQUIRED2, json);
+    return 1;
+  }
+  if (!skipConfirm && (!deps.isTTY.stdin || !deps.isTTY.stdout)) {
+    writeLocalFailure(deps, {
+      code: "ALLOW_LAUNCH_REQUIRES_TTY",
+      message: `candle ${command} needs a terminal: the acknowledgement is typed, and nothing else supplies it.`,
+      suggestion: enabled ? "Run it in an interactive shell; there is no flag and no environment variable for confirm." : "Run it in an interactive shell, or pass --yes to turn it off without the prompt."
+    }, json);
+    return 1;
+  }
+  const request2 = (path, method, body) => apiRequest(path, {
+    method,
+    body,
+    auth: "device",
+    credentials: { deviceToken },
+    apiUrl,
+    fetch: deps.fetch,
+    env: deps.env
+  });
+  const preview = await request2(PREVIEW_PATH, "POST", { wallets: parsed.positionals, enabled });
+  if (!preview.ok)
+    return writeFailure2(ctx, preview);
+  const shown = preview.body;
+  const changing = shown.changed;
+  if (changing.length === 0) {
+    if (json)
+      deps.stdout.write(`${JSON.stringify({ ...shown, command })}
+`);
+    else
+      deps.stdout.write(nothingToChangeLine(shown, enabled));
+    return shown.unchanged.length === 0 && shown.notTee.length > 0 ? 1 : 0;
+  }
+  const n = changing.length;
+  const screen = [
+    allowLaunchTable(changing),
+    ...shown.unchanged.length > 0 ? [`${shown.unchanged.length} already ${enabled ? "on" : "off"}: ${shown.unchanged.map(nameOf).join(", ")}`] : [],
+    ...shown.notTee.length > 0 ? [`Not a TEE wallet, left alone: ${shown.notTee.map(nameOf).join(", ")}`] : [],
+    "",
+    enabled ? `${n === 1 ? "This wallet" : `These ${n} wallets`} will be allowed to pay for a launch: the bound key, with launch:write, can create tokens from ${n === 1 ? "it" : "them"} (candle launch).` : `${n === 1 ? "This wallet" : `These ${n} wallets`} will no longer be able to pay for a launch. Trading is unchanged.`,
+    ""
+  ];
+  deps.stderr.write(`${screen.join(`
+`)}
+`);
+  if (!skipConfirm) {
+    const typed = await deps.promptLine(`Type ${CONFIRM_WORD} to ${enabled ? "allow" : "stop"} launches from ${n === 1 ? "this wallet" : `these ${n} wallets`}: `);
+    if (typed.trim().toLowerCase() !== CONFIRM_WORD) {
+      writeLocalFailure(deps, {
+        code: "ALLOW_LAUNCH_NOT_ACKNOWLEDGED",
+        message: `The acknowledgement is the word ${CONFIRM_WORD}; nothing changed.`,
+        suggestion: `Run the command again and type ${CONFIRM_WORD} at the prompt.`
+      }, json);
+      return 1;
+    }
+  }
+  const done = [];
+  const failed = [];
+  for (const row of changing) {
+    const result = await request2(capabilityPath(row.id), "PUT", { capability: "allowLaunch", enabled });
+    if (result.ok)
+      done.push({ ...row, allowLaunch: enabled });
+    else {
+      failed.push({
+        id: row.id,
+        code: result.status === 404 ? "WALLET_NOT_FOUND" : result.code ?? null,
+        message: result.status === 404 ? "no longer an active TEE wallet on this account" : result.message
+      });
+    }
+  }
+  if (json) {
+    deps.stdout.write(`${JSON.stringify({ success: failed.length === 0, command, enabled, changed: done, unchanged: shown.unchanged, notTee: shown.notTee, failed })}
+`);
+    return failed.length > 0 ? 1 : 0;
+  }
+  const verb = enabled ? "Allowed launches from" : "Stopped launches from";
+  deps.stdout.write(`${verb} ${done.length} wallet${done.length === 1 ? "" : "s"}.
+`);
+  for (const failure of failed) {
+    deps.stderr.write(`Not changed: ${failure.id}: ${failure.message}${failure.code ? ` (${failure.code})` : ""}.
+`);
+  }
+  return failed.length > 0 ? 1 : 0;
+}
+function walletsAllowLaunch(args, ctx) {
+  return setAllowLaunch(args, ctx, true);
+}
+function walletsDisallowLaunch(args, ctx) {
+  return setAllowLaunch(args, ctx, false);
+}
+
 // src/commands/wallets-close-empty.ts
 init_args();
 init_render();
@@ -72484,7 +72775,7 @@ init_promote_support();
 var TRUST_PATH = "/api/v1/agent/linked-wallets/trust";
 var USAGE_TRUST = "Usage: candle wallets trust <label|address|id|prefix*>... [--json]";
 var USAGE_UNTRUST = "Usage: candle wallets untrust <label|address|id|prefix*>... [--yes] [--json]";
-var DEVICE_TOKEN_REQUIRED2 = {
+var DEVICE_TOKEN_REQUIRED3 = {
   code: "DEVICE_TOKEN_REQUIRED",
   message: "Marking a wallet trusted needs the device token, the owner's credential; an API key cannot do it.",
   suggestion: "Run: candle auth login"
@@ -72495,7 +72786,7 @@ function sessionLinkedLine(rows) {
   const names = rows.map((row) => row.label ?? row.address).join(", ");
   return `${n} linked while signed in (${names}): always yours while linked. Revoke ${it} to remove ${it}.`;
 }
-function nothingToChangeLine(shown, trusted) {
+function nothingToChangeLine2(shown, trusted) {
   const session = shown.sessionLinked ?? [];
   const unchanged = shown.unchanged;
   if (session.length > 0 && unchanged.length === 0) {
@@ -72562,7 +72853,7 @@ async function setTrust(args, ctx, trusted) {
   await printIdentity(ctx);
   const deviceToken = await resolveDeviceToken(deps, ctx.profile);
   if (!deviceToken) {
-    writeLocalFailure(deps, DEVICE_TOKEN_REQUIRED2, json);
+    writeLocalFailure(deps, DEVICE_TOKEN_REQUIRED3, json);
     return 1;
   }
   if (!skipConfirm && (!deps.isTTY.stdin || !deps.isTTY.stdout)) {
@@ -72592,7 +72883,7 @@ async function setTrust(args, ctx, trusted) {
       deps.stdout.write(`${JSON.stringify({ ...shown, command })}
 `);
     } else {
-      deps.stdout.write(nothingToChangeLine(shown, trusted));
+      deps.stdout.write(nothingToChangeLine2(shown, trusted));
     }
     return 0;
   }
@@ -72859,6 +73150,8 @@ var COMMANDS = {
       revoke: walletsRevoke,
       trust: walletsTrust,
       untrust: walletsUntrust,
+      "allow-launch": walletsAllowLaunch,
+      "disallow-launch": walletsDisallowLaunch,
       "close-empty": walletsCloseEmpty
     },
     bare: wallets

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@candledottv/cli",
-  "version": "0.11.16",
+  "version": "0.11.17",
   "description": "The Candle CLI: authorize a device from your browser, then manage API keys, wallets, and setup health from the terminal",
   "type": "module",
   "bin": {