@aibtc/mcp-server 1.67.0 → 1.69.0

package/dist/tools/legion.tools.js

@@ -1,13 +1,22 @@
 /**
- * AIBTC News Legion tools (news-gov-v5).
+ * AIBTC News Legion tools (mainnet `aibtc-news-gov`).
  *
- * Lifecycle: inscribe → reveal → propose → vote → veto → conclude, plus
- * contribute (buys weight) and sponsor (does not).
+ * Lifecycle: inscribe → reveal → propose → vote → conclude, plus contribute
+ * (buys weight) and sponsor (does not). There is no veto in this era: voting no
+ * while the window is open is the only way to stop a piece.
+ *
+ * EVERYTHING HERE MOVES REAL VALUE. The legion is on Stacks mainnet holding
+ * real sBTC, and neither `contribute` nor `sponsor` has a withdrawal path, so
+ * both meter against the wallet's `sats` spending rail before signing. That
+ * metering happens inside `callContract`, which reads the exact sBTC
+ * post-condition these calls already sign in DENY mode — so it must NOT be
+ * repeated here, or every contribute would bill the rail twice.
  *
  * These tools pin their own network: `getLegionAccount()` re-derives the
- * unlocked wallet for the legion's chain, so a mainnet-configured server signs
- * against testnet. Inscription is the exception — real BTC on whatever chain
- * NETWORK names.
+ * unlocked wallet for the legion's chain, so a testnet-configured server still
+ * signs against the mainnet contracts rather than quietly reading a chain the
+ * legion does not live on. Inscription is the exception — it follows the global
+ * NETWORK, because ordinals.com indexes Bitcoin mainnet only.
  *
  * Fund-moving calls sign in DENY mode with an exact post-condition.
  */
@@ -16,8 +25,8 @@ import { z } from "zod";
 import { Pc, boolCV, noneCV, principalCV, someCV, stringAsciiCV, uintCV, PostConditionMode, } from "@stacks/transactions";
 import { NETWORK, getExplorerTxUrl } from "../config/networks.js";
 import { DUST_THRESHOLD } from "../config/bitcoin-constants.js";
-import { LEGION_ERRORS, LEGION_GOV_CONTRACT, LEGION_NETWORK, LEGION_SITE_URL, LEGION_TREASURY_CONTRACT, MAX_DESCRIPTION_LENGTH, MAX_LINK_LENGTH, MAX_SPONSOR_LINK_LENGTH, MAX_SPONSOR_MEMO_LENGTH, MAX_SPONSOR_NAME_LENGTH, MAX_TITLE_LENGTH, ORDINALS_CONTENT_BASE, ORDINALS_INSCRIPTION_BASE, STORY_STATUS, } from "../config/legion.js";
-import { assertAscii, buildTimeline, contentUrlFromLink, explainError, getClockHeight, getLastProposalId, getLegionAccount, getLegionToken, getParams, getPhase, getProposeStatus, getStory, getStoryMeta, getVetoRecord, getVoteRecord, inscriptionIdFromLink, normalizeOrdinalsLink, num, predictOutcome, proposeBlockers, readGov, readLegionContract, readTreasury, } from "../services/legion.service.js";
+import { LEGION_ERAS, LEGION_ERRORS, LEGION_NETWORK, LEGION_SITE_URL, LIVE_ERA, MAX_DESCRIPTION_LENGTH, MAX_LINK_LENGTH, MAX_RATIONALE_LENGTH, MAX_SPONSOR_LINK_LENGTH, MAX_SPONSOR_MEMO_LENGTH, MAX_SPONSOR_NAME_LENGTH, MAX_TITLE_LENGTH, ORDINALS_CONTENT_BASE, ORDINALS_INSCRIPTION_BASE, STORY_STATUS, resolveEra, } from "../config/legion.js";
+import { assertAscii, buildTimeline, contentUrlFromLink, explainError, getClockHeight, getLastProposalId, getLegionAccount, getLegionToken, getMembership, getParams, getPhase, getProposeStatus, getStory, getStoryMeta, getVoteRecord, inscriptionIdFromLink, normalizeOrdinalsLink, num, predictOutcome, proposeBlockers, readGov, readLegionContract, readTreasury, } from "../services/legion.service.js";
 import { callContract } from "../transactions/builder.js";
 import { getWalletManager } from "../services/wallet-manager.js";
 import { MempoolApi, getMempoolTxUrl } from "../services/mempool-api.js";
@@ -25,8 +34,17 @@ import { buildCommitTransaction, buildRevealTransaction, deriveRevealScript, } f
 import { buildChildCommitTransaction, buildChildRevealTransaction, deriveChildRevealScript, lookupParentInscription, } from "../transactions/child-inscription-builder.js";
 import { signBtcTransaction } from "../transactions/bitcoin-builder.js";
 import { createErrorResponse, createJsonResponse } from "../utils/index.js";
-const [GOV_ADDRESS, GOV_NAME] = LEGION_GOV_CONTRACT.split(".");
-const [TREASURY_ADDRESS, TREASURY_NAME] = LEGION_TREASURY_CONTRACT.split(".");
+// Writes always target the live era. A retired contract still answers reads,
+// but proposing or voting into one would govern a deployment nothing watches.
+const [GOV_ADDRESS, GOV_NAME] = LIVE_ERA.gov.split(".");
+const [TREASURY_ADDRESS, TREASURY_NAME] = LIVE_ERA.treasury.split(".");
+/** The `era` input shared by every read tool. */
+const eraInput = z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe(`Which legion deployment to read: ${LEGION_ERAS.map((e) => `${e.version}${e.live ? " (live, default)" : " (retired)"}`).join(", ")}. Proposal ids restart at 1 each era, so an id alone is ambiguous.`);
 /** Markdown, so the inscription renders as a story rather than a wall of text. */
 const STORY_CONTENT_TYPE = "text/markdown;charset=utf-8";
 /**
@@ -41,17 +59,17 @@ const LARGE_INSCRIPTION_WARN_BYTES = 100_000;
 /**
  * Phases that mean the piece is still moving, for the `live` list filter.
  * `pending` is a phase, not a stored status — a proposal is OPEN in storage
- * from the moment it is filed, but voting does not open until votingDelay
+ * from the moment it is filed, but voting does not open until voteDelay
  * blocks later.
  */
-const LIVE_PHASES = ["pending", "voting", "veto", "concludable"];
+const LIVE_PHASES = ["pending", "voting", "concludable"];
 /** Errors surface as sentences, with the contract's `uXXX` still attached. */
 function legionError(error) {
     return createErrorResponse(new Error(explainError(error, LEGION_ERRORS)));
 }
 /** An sBTC balance on the legion's chain, in sats. */
-async function sbtcBalance(address) {
-    const token = await getLegionToken();
+async function sbtcBalance(address, era = LIVE_ERA) {
+    const token = await getLegionToken(era);
     return num(await readLegionContract(token.contract, "get-balance", [
         principalCV(address),
     ]));
@@ -128,33 +146,38 @@ export function registerLegionTools(server) {
     // legion_status — the whole legion in one read
     // ==========================================================================
     server.registerTool("legion_status", {
-        description: "News Legion at a glance: sBTC pool, total weight, governance params read from the " +
-            "contract, current height, and your own weight if a wallet is unlocked. Start here.\n\n" +
+        description: "News Legion at a glance: sBTC pool, total weight, membership and whether the legion " +
+            "is ACTIVATED yet, governance params read from the contract, current height, and your " +
+            "own weight if a wallet is unlocked. Start here.\n\n" +
+            "No story can be proposed until the legion reaches its member threshold, so check " +
+            "`membership.activated` before planning to publish.\n\n" +
             `Reads only. Runs on Stacks ${LEGION_NETWORK} regardless of this server's NETWORK.`,
-        inputSchema: {},
-    }, async () => {
+        inputSchema: { era: eraInput },
+    }, async ({ era: eraArg }) => {
         try {
-            const [params, clock, pool, weighted, totalWeight, lastProposalId, nextProposeHeight, quoteDraw, minSponsor, govWiring,] = await Promise.all([
-                getParams(),
-                getClockHeight(),
-                readTreasury("get-balance"),
-                readTreasury("get-weighted-balance"),
-                readGov("get-total-weight"),
-                getLastProposalId(),
-                readGov("get-next-propose-height"),
-                readGov("quote-draw"),
-                readTreasury("get-min-sponsor"),
-                readTreasury("get-gov"),
+            const era = resolveEra(eraArg);
+            const [params, clock, pool, weighted, totalWeight, lastProposalId, nextProposeHeight, quotePayout, minSponsor, govWiring, membership,] = await Promise.all([
+                getParams(era),
+                getClockHeight(era),
+                readTreasury("get-balance", [], era),
+                readTreasury("get-weighted-balance", [], era),
+                readGov("get-total-weight", [], era),
+                getLastProposalId(era),
+                readGov("get-next-propose-height", [], era),
+                readGov("quote-payout", [], era),
+                readTreasury("get-min-sponsor", [], era),
+                readTreasury("get-gov", [], era),
+                getMembership(era),
             ]);
             const walletManager = getWalletManager();
             let you;
             if (walletManager.isUnlocked() || process.env.CLIENT_MNEMONIC) {
                 const account = await getLegionAccount();
                 const [weight, freeWeight, liveProposal, balance] = await Promise.all([
-                    readGov("get-weight", [principalCV(account.address)]),
-                    readGov("get-free-weight", [principalCV(account.address)]),
-                    readGov("get-live-proposal", [principalCV(account.address)]),
-                    sbtcBalance(account.address),
+                    readGov("get-weight", [principalCV(account.address)], era),
+                    readGov("get-free-weight", [principalCV(account.address)], era),
+                    readGov("get-live-proposal", [principalCV(account.address)], era),
+                    sbtcBalance(account.address, era),
                 ]);
                 you = {
                     address: account.address,
@@ -169,10 +192,18 @@ export function registerLegionTools(server) {
             }
             return createJsonResponse({
                 network: LEGION_NETWORK,
+                era: {
+                    version: era.version,
+                    live: era.live,
+                    known: LEGION_ERAS.map((e) => ({ version: e.version, live: e.live })),
+                    note: era.live
+                        ? undefined
+                        : `v${era.version} is retired — it still answers reads, but every write goes to v${LIVE_ERA.version}.`,
+                },
                 contracts: {
-                    governance: LEGION_GOV_CONTRACT,
-                    treasury: LEGION_TREASURY_CONTRACT,
-                    sbtcToken: (await getLegionToken()).contract,
+                    governance: era.gov,
+                    treasury: era.treasury,
+                    sbtcToken: (await getLegionToken(era)).contract,
                     treasuryWiredTo: govWiring,
                 },
                 site: LEGION_SITE_URL,
@@ -186,23 +217,35 @@ export function registerLegionTools(server) {
                     weightedBalanceSats: num(weighted),
                     sponsoredSats: num(pool) - num(weighted),
                     note: "New weight is priced against weightedBalance (contributed sats only), " +
-                        "so sponsorships never raise the cost of joining — but the draw is a " +
+                        "so sponsorships never raise the cost of joining — but the payout is a " +
                         "fraction of the WHOLE pool, so they do enlarge every payout.",
                 },
+                membership: {
+                    ...membership,
+                    note: membership.activated
+                        ? "The legion is activated — proposals are open."
+                        : `NOT ACTIVATED. ${membership.membersNeeded} more principals must each hold ` +
+                            `at least ${params.minWeightToAct} weight before any story can be proposed ` +
+                            `(u441). Contributing more sats yourself does not help — the gate counts ` +
+                            `distinct members, not weight.`,
+                },
                 governance: {
                     totalWeight: num(totalWeight),
                     lastProposalId,
                     nextProposeHeight: num(nextProposeHeight),
                     proposeSlotOpen: num(nextProposeHeight) <= clock.height,
-                    currentDrawSats: num(quoteDraw),
+                    currentPayoutSats: num(quotePayout),
                     minSponsorSats: num(minSponsor),
                     params,
+                    howAStoryPasses: `At least ${params.minVoters} distinct voter(s), at least ` +
+                        `${params.votingThreshold}% of cast weight voting yes, AND yes weight of at ` +
+                        `least ${params.yesMultiple}x the payout. There is no quorum and no veto.`,
                 },
                 you,
                 nextSteps: [
                     "legion_list_stories — what is open for a vote right now",
-                    "legion_my_position — your weight, bond and whether you can propose",
-                    "legion_contribute — buy voting weight with sBTC",
+                    "legion_my_position — your weight, lock and whether you can propose",
+                    "legion_contribute — buy voting weight with sBTC (spends real sBTC, no refund)",
                     "legion_sponsor — fund the pool without buying a vote",
                 ],
             });
@@ -216,7 +259,7 @@ export function registerLegionTools(server) {
     // ==========================================================================
     server.registerTool("legion_list_stories", {
         description: "Proposals newest first, with phase, tally and the inscription each points at.\n\n" +
-            "Phases: `pending` (filed, voting not open yet), `voting`, `veto`, `concludable`, " +
+            "Phases: `pending` (filed, voting not open yet), `voting`, `concludable`, " +
             "`passed`/`failed` (settled), `expired` (nobody concluded in time; can no longer pay).\n\n" +
             "Reads only.",
         inputSchema: {
@@ -226,14 +269,13 @@ export function registerLegionTools(server) {
                 "live",
                 "pending",
                 "voting",
-                "veto",
                 "concludable",
                 "passed",
                 "failed",
                 "expired",
             ])
                 .optional()
-                .describe("Filter by phase. 'live' means pending+voting+veto+concludable. Default: all"),
+                .describe("Filter by phase. 'live' means pending+voting+concludable. Default: all"),
             limit: z
                 .number()
                 .int()
@@ -241,21 +283,24 @@ export function registerLegionTools(server) {
                 .max(50)
                 .optional()
                 .describe("How many proposals to scan back from the newest (default 10)"),
+            era: eraInput,
         },
-    }, async ({ phase = "all", limit = 10 }) => {
+    }, async ({ phase = "all", limit = 10, era: eraArg }) => {
         try {
+            const era = resolveEra(eraArg);
             const [params, clock, lastProposalId, pool] = await Promise.all([
-                getParams(),
-                getClockHeight(),
-                getLastProposalId(),
-                readTreasury("get-balance"),
+                getParams(era),
+                getClockHeight(era),
+                getLastProposalId(era),
+                readTreasury("get-balance", [], era),
             ]);
             if (lastProposalId === 0) {
                 return createJsonResponse({
                     network: LEGION_NETWORK,
+                    era: era.version,
                     totalProposals: 0,
                     stories: [],
-                    message: "No proposals have been filed in this legion yet.",
+                    message: `No proposals have been filed in legion v${era.version} yet.`,
                 });
             }
             const firstId = Math.max(1, lastProposalId - limit + 1);
@@ -264,9 +309,9 @@ export function registerLegionTools(server) {
                 ids.push(id);
             const rows = await Promise.all(ids.map(async (proposalId) => {
                 const [story, meta, storyPhase] = await Promise.all([
-                    getStory(proposalId),
-                    getStoryMeta(proposalId),
-                    getPhase(proposalId),
+                    getStory(proposalId, era),
+                    getStoryMeta(proposalId, era),
+                    getPhase(proposalId, era),
                 ]);
                 if (!story)
                     return null;
@@ -274,6 +319,7 @@ export function registerLegionTools(server) {
                 const prediction = predictOutcome(story, params, num(pool), clock.height);
                 return {
                     proposalId,
+                    era: era.version,
                     phase: storyPhase,
                     status: STORY_STATUS[story.status],
                     reason: story.reason || undefined,
@@ -282,13 +328,13 @@ export function registerLegionTools(server) {
                     inscriptionId: meta ? inscriptionIdFromLink(meta.link) : null,
                     contentUrl: meta ? contentUrlFromLink(meta.link) : null,
                     proposer: story.proposer,
-                    drawSats: story.draw,
+                    payoutSats: story.payout,
                     tally: {
                         yes: story.yesWeight,
                         no: story.noWeight,
-                        veto: story.vetoWeight,
+                        yesNeeded: prediction.yesWeightRequired,
                         voters: story.voterCount,
-                        eligible: story.eligibleSnapshot,
+                        totalWeightAtOpen: story.totalWeightAtOpen,
                     },
                     blocksUntilNextTransition: timeline.blocksUntilNextTransition,
                     ifConcludedNow: prediction.settled
@@ -307,6 +353,7 @@ export function registerLegionTools(server) {
             });
             return createJsonResponse({
                 network: LEGION_NETWORK,
+                era: { version: era.version, live: era.live, gov: era.gov },
                 currentHeight: clock.height,
                 clock: `${clock.clock} blocks`,
                 totalProposals: lastProposalId,
@@ -326,25 +373,27 @@ export function registerLegionTools(server) {
     // legion_get_story — one proposal in full
     // ==========================================================================
     server.registerTool("legion_get_story", {
-        description: "One proposal in full: tally against the quorum and threshold it must clear, the " +
-            "window timeline, what `conclude` would decide now, and whether you have voted.\n\n" +
+        description: "One proposal in full: the tally against all three gates it must clear, the window " +
+            "timeline, what `conclude` would decide now, and whether you have voted.\n\n" +
             "Read this before voting — the contract cannot read the inscription, so judging the " +
             "work is the voter's job.\n\nReads only.",
         inputSchema: {
             proposalId: z.number().int().positive().describe("The proposal id"),
+            era: eraInput,
         },
-    }, async ({ proposalId }) => {
+    }, async ({ proposalId, era: eraArg }) => {
         try {
+            const era = resolveEra(eraArg);
             const [params, clock, story, meta, storyPhase, pool] = await Promise.all([
-                getParams(),
-                getClockHeight(),
-                getStory(proposalId),
-                getStoryMeta(proposalId),
-                getPhase(proposalId),
-                readTreasury("get-balance"),
+                getParams(era),
+                getClockHeight(era),
+                getStory(proposalId, era),
+                getStoryMeta(proposalId, era),
+                getPhase(proposalId, era),
+                readTreasury("get-balance", [], era),
             ]);
             if (!story) {
-                return createErrorResponse(new Error(`No proposal ${proposalId} in ${LEGION_GOV_CONTRACT}. ` +
+                return createErrorResponse(new Error(`No proposal ${proposalId} in ${era.gov} (v${era.version}). ` +
                     `Call legion_list_stories to see what exists.`));
             }
             const timeline = buildTimeline(story, params, clock.height, clock.clock);
@@ -353,30 +402,26 @@ export function registerLegionTools(server) {
             let you;
             if (walletManager.isUnlocked() || process.env.CLIENT_MNEMONIC) {
                 const account = await getLegionAccount();
-                const [voteRecord, vetoRecord, weight] = await Promise.all([
-                    getVoteRecord(proposalId, account.address),
-                    getVetoRecord(proposalId, account.address),
-                    readGov("get-weight", [principalCV(account.address)]),
+                const [voteRecord, weight] = await Promise.all([
+                    getVoteRecord(proposalId, account.address, era),
+                    readGov("get-weight", [principalCV(account.address)], era),
                 ]);
                 you = {
                     address: account.address,
                     weight: num(weight),
                     isProposer: account.address === story.proposer,
                     voted: voteRecord,
-                    vetoed: vetoRecord,
                     canVoteNow: storyPhase === "voting" &&
                         !voteRecord &&
                         account.address !== story.proposer &&
-                        num(weight) >= params.minWeight,
-                    canVetoNow: storyPhase === "veto" &&
-                        !vetoRecord &&
-                        num(weight) >= params.minWeight,
+                        num(weight) >= params.minWeightToAct,
                     canConcludeNow: storyPhase === "concludable",
                 };
             }
             return createJsonResponse({
                 proposalId,
                 network: LEGION_NETWORK,
+                era: { version: era.version, live: era.live },
                 phase: storyPhase,
                 status: STORY_STATUS[story.status],
                 reason: story.reason || undefined,
@@ -386,35 +431,47 @@ export function registerLegionTools(server) {
                 inscriptionId: meta ? inscriptionIdFromLink(meta.link) : null,
                 contentUrl: meta ? contentUrlFromLink(meta.link) : null,
                 proposer: story.proposer,
-                drawSats: story.draw,
-                bondWeight: story.bond,
+                payoutSats: story.payout,
+                lockedWeight: story.lockedWeight,
                 tally: {
                     yesWeight: story.yesWeight,
                     noWeight: story.noWeight,
-                    vetoWeight: story.vetoWeight,
                     castWeight: prediction.cast,
                     voterCount: story.voterCount,
-                    eligibleSnapshot: story.eligibleSnapshot,
+                    totalWeightAtOpen: story.totalWeightAtOpen,
                 },
-                thresholds: {
-                    quorumPct: prediction.quorumPct,
-                    quorumRequiredPct: params.votingQuorum,
-                    quorumMet: prediction.quorumMet,
-                    yesPct: prediction.yesPct,
-                    thresholdRequiredPct: params.votingThreshold,
-                    thresholdMet: prediction.thresholdMet,
-                    vetoPct: prediction.vetoPct,
-                    vetoQuorumPct: params.vetoQuorum,
-                    vetoed: prediction.vetoed,
-                    participants: `${story.voterCount}/${params.minParticipants}`,
-                    participantsMet: prediction.participantsMet,
+                // The three gates conclude applies, in the contract's own order. There
+                // is no quorum: turnout alone can never fail a piece here.
+                gates: {
+                    voters: {
+                        have: story.voterCount,
+                        need: params.minVoters,
+                        met: prediction.votersMet,
+                        failsAs: "no-voters",
+                    },
+                    threshold: {
+                        yesPct: prediction.yesPct,
+                        needPct: params.votingThreshold,
+                        met: prediction.thresholdMet,
+                        failsAs: "voted-down",
+                    },
+                    yesWeight: {
+                        have: story.yesWeight,
+                        need: prediction.yesWeightRequired,
+                        met: prediction.yesMet,
+                        failsAs: "yes-short",
+                        explanation: `Yes weight must cover ${params.yesMultiple}x the ${story.payout} sat payout. ` +
+                            `A piece can be approved ${params.votingThreshold}%+ and still fail here — ` +
+                            `that is the brake on a thin majority voting money out of a large pool.`,
+                    },
                 },
                 timeline: {
                     ...timeline,
                     explanation: `Filed at ${timeline.createdAt}. Voting opens at ${timeline.votingOpensAt} ` +
-                        `and closes at ${timeline.voteEnd}. Veto runs until ${timeline.vetoEnd}. ` +
-                        `Conclude must be called before ${timeline.concludeDeadline} — after that ` +
-                        `the piece has expired and can no longer be concluded at all.`,
+                        `and closes at ${timeline.voteEnd}. There is no veto window, so conclude opens ` +
+                        `as soon as voting closes. Conclude must be called before ` +
+                        `${timeline.concludeDeadline} — after that the piece has expired and can no ` +
+                        `longer be concluded at all.`,
                 },
                 outcome: {
                     settled: prediction.settled,
@@ -437,93 +494,63 @@ export function registerLegionTools(server) {
     // legion_my_position — your standing
     // ==========================================================================
     server.registerTool("legion_my_position", {
-        description: "Your weight, share, bond lock, sBTC balance, and every propose precondition folded " +
+        description: "Your weight, share, weight lock, sBTC balance, and every propose precondition folded " +
             "from the contract's `propose-status` — so a blocked propose names the gate to wait on.\n\n" +
             "Requires an unlocked wallet. Signs nothing.",
-        inputSchema: {},
-    }, async () => {
+        inputSchema: { era: eraInput },
+    }, async ({ era: eraArg }) => {
         try {
+            const era = resolveEra(eraArg);
             const account = await getLegionAccount();
-            const [params, clock, weight, freeWeight, locked, liveProposal, totalWeight, proposeStatus, balance, quoteDraw] = await Promise.all([
-                getParams(),
-                getClockHeight(),
-                readGov("get-weight", [principalCV(account.address)]),
-                readGov("get-free-weight", [principalCV(account.address)]),
-                readGov("locked-of", [principalCV(account.address)]),
-                readGov("get-live-proposal", [principalCV(account.address)]),
-                readGov("get-total-weight"),
-                getProposeStatus(account.address),
-                sbtcBalance(account.address),
-                readGov("quote-draw"),
+            const [params, clock, weight, freeWeight, locked, lockedUntil, liveProposal, totalWeight, proposeStatus, balance, quotePayout] = await Promise.all([
+                getParams(era),
+                getClockHeight(era),
+                readGov("get-weight", [principalCV(account.address)], era),
+                readGov("get-free-weight", [principalCV(account.address)], era),
+                readGov("get-locked-weight", [principalCV(account.address)], era),
+                readGov("get-locked-until", [principalCV(account.address)], era),
+                readGov("get-live-proposal", [principalCV(account.address)], era),
+                readGov("get-total-weight", [], era),
+                getProposeStatus(account.address, era),
+                sbtcBalance(account.address, era),
+                readGov("quote-payout", [], era),
             ]);
-            const blockers = proposeBlockers(proposeStatus, params.minWeight);
+            const blockers = proposeBlockers(proposeStatus, params.minWeightToAct);
             return createJsonResponse({
                 address: account.address,
                 network: LEGION_NETWORK,
+                era: { version: era.version, live: era.live },
                 currentHeight: clock.height,
                 weight: num(weight),
                 freeWeight: num(freeWeight),
                 lockedWeight: num(locked),
+                lockedUntilHeight: num(lockedUntil),
                 sharePct: num(totalWeight) > 0
                     ? Number(((num(weight) * 100) / num(totalWeight)).toFixed(4))
                     : 0,
                 totalWeight: num(totalWeight),
                 sbtcBalanceSats: balance,
                 liveProposalId: liveProposal === null ? null : num(liveProposal),
-                canVote: num(weight) >= params.minWeight,
+                canVote: num(weight) >= params.minWeightToAct,
+                isMember: num(weight) >= params.minWeightToAct,
+                membership: {
+                    memberCount: proposeStatus.memberCount,
+                    membersToActivate: proposeStatus.membersToActivate,
+                    activated: proposeStatus.membersOk,
+                },
                 propose: {
                     canPropose: proposeStatus.canPropose,
                     blockers: blockers.length > 0 ? blockers : undefined,
                     weightLockedOnPropose: proposeStatus.lockOnPropose,
-                    wouldPaySats: proposeStatus.draw,
+                    wouldPaySats: proposeStatus.payout,
                     nextProposeHeight: proposeStatus.nextProposeHeight,
                     note: "Proposing locks your ENTIRE weight until the piece resolves. The lock is " +
                         "never spent and never reduces your voting power — it exists only to enforce " +
                         "one live proposal per principal, and releases on every outcome.",
                 },
-                currentDrawSats: num(quoteDraw),
-                minWeightToVoteOrPropose: params.minWeight,
-                minContributionSats: params.minContribution,
-            });
-        }
-        catch (error) {
-            return legionError(error);
-        }
-    });
-    // ==========================================================================
-    // legion_faucet — testnet sBTC
-    // ==========================================================================
-    server.registerTool("legion_faucet", {
-        description: "Mint testnet sBTC from the faucet on this legion's token contract.\n\n" +
-            "Testnet only. Requires an unlocked wallet.",
-        inputSchema: {},
-    }, async () => {
-        try {
-            if (LEGION_NETWORK !== "testnet") {
-                return createErrorResponse(new Error(`The legion is on ${LEGION_NETWORK}, which has no sBTC faucet. ` +
-                    `Acquire sBTC with sbtc_deposit or styx_deposit instead.`));
-            }
-            const account = await getLegionAccount();
-            const token = await getLegionToken();
-            const [tokenAddress, tokenName] = token.contract.split(".");
-            const result = await callContract(account, {
-                contractAddress: tokenAddress,
-                contractName: tokenName,
-                functionName: "faucet",
-                functionArgs: [],
-                // A faucet mints rather than transfers, and mints have no sender to
-                // write a condition against.
-                postConditionMode: PostConditionMode.Allow,
-                postConditions: [],
-            });
-            return createJsonResponse({
-                success: true,
-                txid: result.txid,
-                explorerUrl: explorerUrl(result.txid),
-                address: account.address,
-                token: token.contract,
-                network: LEGION_NETWORK,
-                nextStep: "Once it confirms, call legion_contribute to turn sBTC into voting weight.",
+                currentPayoutSats: num(quotePayout),
+                minWeightToVoteOrPropose: params.minWeightToAct,
+                minJoinSats: params.minJoinSats,
             });
         }
         catch (error) {
@@ -536,8 +563,13 @@ export function registerLegionTools(server) {
     server.registerTool("legion_contribute", {
         description: "Send sBTC to the pool and receive voting weight proportional to your share of the " +
             "contributed balance.\n\n" +
-            "NOT REFUNDABLE — you get a say in which pieces get paid, not a claim on the pool. " +
-            "To fund the pool without a vote, use legion_sponsor.\n\n" +
+            "SPENDS REAL sBTC AND IS NOT REFUNDABLE — you get a say in which pieces get paid, not " +
+            "a claim on the pool. There is no withdrawal function. To fund the pool without a " +
+            "vote, use legion_sponsor.\n\n" +
+            "Metered against the wallet's `sats` spending limit before signing, so a large " +
+            "contribution blocks until you raise SPEND_LIMIT_SESSION_SATS.\n\n" +
+            "Crossing the minimum weight also makes you a MEMBER, which is what unlocks proposals " +
+            "for the whole legion once enough members join.\n\n" +
             "Requires an unlocked wallet.",
         inputSchema: {
             sats: z
@@ -549,22 +581,24 @@ export function registerLegionTools(server) {
     }, async ({ sats }) => {
         try {
             const account = await getLegionAccount();
-            const [params, token, balance, weightBefore] = await Promise.all([
+            const [params, token, balance, weightBefore, membership] = await Promise.all([
                 getParams(),
                 getLegionToken(),
                 sbtcBalance(account.address),
                 readGov("get-weight", [principalCV(account.address)]),
+                getMembership(),
             ]);
-            if (sats < params.minContribution) {
+            if (sats < params.minJoinSats) {
                 return createErrorResponse(new Error(`${sats} sats is below the legion's minimum contribution of ` +
-                    `${params.minContribution} sats (u437).`));
+                    `${params.minJoinSats} sats (u437).`));
             }
             if (balance < sats) {
                 return createErrorResponse(new Error(`Your sBTC balance is ${balance} sats — not enough to contribute ${sats}. ` +
-                    (LEGION_NETWORK === "testnet"
-                        ? "Call legion_faucet for testnet sBTC."
-                        : "Acquire sBTC first.")));
+                    `Acquire sBTC with sbtc_deposit or styx_deposit first.`));
             }
+            // Real, unrecoverable sBTC leaves the wallet here. The `sats` rail is
+            // metered by callContract off the willSendEq post-condition below —
+            // metering again here would double-bill the cap.
             const quotedWeight = num(await readGov("quote-weight", [uintCV(sats)]));
             const result = await callContract(account, {
                 contractAddress: GOV_ADDRESS,
@@ -578,6 +612,9 @@ export function registerLegionTools(server) {
                         .ft(token.contract, token.assetName),
                 ],
             });
+            const weightAfter = num(weightBefore) + quotedWeight;
+            const wasMember = num(weightBefore) >= params.minWeightToAct;
+            const willBeMember = weightAfter >= params.minWeightToAct;
             return createJsonResponse({
                 success: true,
                 txid: result.txid,
@@ -586,12 +623,22 @@ export function registerLegionTools(server) {
                 contributedSats: sats,
                 expectedWeightMinted: quotedWeight,
                 weightBefore: num(weightBefore),
-                expectedWeightAfter: num(weightBefore) + quotedWeight,
+                expectedWeightAfter: weightAfter,
                 network: LEGION_NETWORK,
-                warning: "Contributions are final. There is no withdrawal path.",
-                nextStep: quotedWeight + num(weightBefore) >= params.minWeight
-                    ? "Once it confirms you can legion_vote and legion_propose_story."
-                    : `You will still be below minWeight (${params.minWeight}) — contribute more to vote or propose.`,
+                membership: {
+                    joiningAsNewMember: !wasMember && willBeMember,
+                    memberCountBefore: membership.memberCount,
+                    membersToActivate: membership.membersToActivate,
+                    activated: membership.activated,
+                },
+                warning: "Contributions are final and spend real sBTC. There is no withdrawal path.",
+                nextStep: willBeMember
+                    ? membership.activated
+                        ? "Once it confirms you can legion_vote and legion_propose_story."
+                        : `Once it confirms you can legion_vote. Proposing stays blocked until the ` +
+                            `legion reaches ${membership.membersToActivate} members (u441).`
+                    : `You will still be below minWeightToAct (${params.minWeightToAct}) — contribute ` +
+                        `more to vote or propose.`,
             });
         }
         catch (error) {
@@ -604,9 +651,10 @@ export function registerLegionTools(server) {
     server.registerTool("legion_sponsor", {
         description: "Fund the pool WITHOUT minting voting weight, with a name on the record.\n\n" +
             "Does not raise the price of joining (weight is priced against contributed sats only), " +
-            "but does enlarge every payout, since the draw is a fraction of the whole pool.\n\n" +
+            "but does enlarge every payout, since the payout is a fraction of the whole pool.\n\n" +
             "`name`, `link` and `memo` are unverified — the paying principal and txid are the real " +
-            "identity. FINAL: no refund path exists.\n\n" +
+            "identity. SPENDS REAL sBTC AND IS FINAL: no refund path exists.\n\n" +
+            "Metered against the wallet's `sats` spending limit before signing.\n\n" +
             "Requires an unlocked wallet.",
         inputSchema: {
             sats: z
@@ -641,7 +689,7 @@ export function registerLegionTools(server) {
             const [token, minSponsor, balance] = await Promise.all([
                 getLegionToken(),
                 readTreasury("get-min-sponsor"),
-                sbtcBalance((await getLegionAccount()).address),
+                sbtcBalance(account.address),
             ]);
             if (sats < num(minSponsor)) {
                 return createErrorResponse(new Error(`${sats} sats is below the treasury's minimum sponsorship of ` +
@@ -650,6 +698,8 @@ export function registerLegionTools(server) {
             if (balance < sats) {
                 return createErrorResponse(new Error(`Your sBTC balance is ${balance} sats — not enough to sponsor ${sats}.`));
             }
+            // Same rail as contribute: real sBTC, no refund, metered by callContract
+            // off the post-condition below.
             const result = await callContract(account, {
                 contractAddress: TREASURY_ADDRESS,
                 contractName: TREASURY_NAME,
@@ -678,7 +728,7 @@ export function registerLegionTools(server) {
                 memo: memo ?? "",
                 mintedWeight: 0,
                 network: LEGION_NETWORK,
-                warning: "Final. No refund path exists. This mints no voting weight — use " +
+                warning: "Final. Real sBTC, and no refund path exists. This mints no voting weight — use " +
                     "legion_contribute if you wanted a vote.",
                 note: "How long a sponsor badge shows is decided off-chain by the reader at " +
                     `${LEGION_SITE_URL}, not by the contract.`,
@@ -692,8 +742,10 @@ export function registerLegionTools(server) {
     // legion_propose_story — open the vote on an inscribed piece
     // ==========================================================================
     server.registerTool("legion_propose_story", {
-        description: "Open a vote on one inscribed piece. If it passes, YOU are paid the draw — the " +
+        description: "Open a vote on one inscribed piece. If it passes, YOU are paid the payout — the " +
             "proposer is the only reachable payee.\n\n" +
+            "The legion must be ACTIVATED first: until it reaches its member threshold, every " +
+            "propose reverts (u441) no matter how much weight you hold. Check legion_status.\n\n" +
             "The contract stores link, title and description verbatim and never reads the " +
             "inscription. Proposing locks your ENTIRE weight until the piece resolves — one live " +
             "proposal per principal; the lock is never spent and releases on every outcome.\n\n" +
@@ -731,7 +783,7 @@ export function registerLegionTools(server) {
                 getClockHeight(),
             ]);
             if (!proposeStatus.canPropose) {
-                const blockers = proposeBlockers(proposeStatus, params.minWeight);
+                const blockers = proposeBlockers(proposeStatus, params.minWeightToAct);
                 return createErrorResponse(new Error(`Cannot propose right now: ${blockers.join("; ")}. ` +
                     `Current height ${clock.height}. Nothing was signed.`));
             }
@@ -744,12 +796,12 @@ export function registerLegionTools(server) {
                     stringAsciiCV(title),
                     stringAsciiCV(body),
                 ],
-                // The bond is weight, not sats: no sBTC moves on propose, so DENY with
+                // The lock is weight, not sats: no sBTC moves on propose, so DENY with
                 // no conditions is exactly right.
                 postConditionMode: PostConditionMode.Deny,
                 postConditions: [],
             });
-            const votingOpensAt = clock.height + params.votingDelay;
+            const votingOpensAt = clock.height + params.voteDelay;
             const voteEnd = votingOpensAt + params.voteWindow;
             return createJsonResponse({
                 success: true,
@@ -762,19 +814,22 @@ export function registerLegionTools(server) {
                 description: body,
                 network: LEGION_NETWORK,
                 weightLocked: proposeStatus.lockOnPropose,
-                expectedDrawSats: proposeStatus.draw,
+                expectedPayoutSats: proposeStatus.payout,
+                yesWeightNeeded: proposeStatus.payout * params.yesMultiple,
                 expectedTimeline: {
                     note: "Approximate — the contract snapshots these at the block that mines the tx.",
                     filedAtAbout: clock.height,
                     votingOpensAbout: votingOpensAt,
                     voteEndsAbout: voteEnd,
-                    vetoEndsAbout: voteEnd + params.vetoWindow,
-                    concludeDeadlineAbout: voteEnd + params.vetoWindow + params.concludeWindow,
+                    concludeDeadlineAbout: voteEnd + params.concludeWindow,
                     clock: `${clock.clock} blocks`,
                 },
                 nextSteps: [
                     "legion_list_stories to pick up the assigned proposalId once it confirms",
-                    `Votes cannot be cast for ~${params.votingDelay} blocks (the pending period)`,
+                    `Votes cannot be cast for ~${params.voteDelay} blocks (the pending period)`,
+                    `To be paid, this needs ${params.minVoters}+ voter(s), ${params.votingThreshold}% ` +
+                        `yes, AND at least ${proposeStatus.payout * params.yesMultiple} yes weight — ` +
+                        `you cannot vote for your own piece, so that weight must come from others`,
                     "Someone must call legion_conclude inside the conclude window or the piece expires and pays nobody",
                 ],
             });
@@ -787,8 +842,10 @@ export function registerLegionTools(server) {
     // legion_vote
     // ==========================================================================
     server.registerTool("legion_vote", {
-        description: "Vote yes or no with your current weight. One vote per principal; a proposer cannot " +
-            "vote on their own piece.\n\n" +
+        description: "Vote yes or no with your current weight, with a written rationale recorded on chain. " +
+            "One vote per principal; a proposer cannot vote on their own piece. Votes cannot be " +
+            "changed.\n\n" +
+            "Voting no is the ONLY way to stop a piece — this legion has no veto.\n\n" +
             "Read the inscription first — legion_get_story gives you the link.\n\n" +
             "Pre-flights phase, weight and prior vote. Requires an unlocked wallet.",
         inputSchema: {
@@ -796,8 +853,14 @@ export function registerLegionTools(server) {
             support: z
                 .boolean()
                 .describe("true = yes (pay this piece), false = no"),
+            rationale: z
+                .string()
+                .min(1)
+                .max(MAX_RATIONALE_LENGTH)
+                .describe(`Why you voted this way, recorded on chain (ASCII, ≤${MAX_RATIONALE_LENGTH} chars). ` +
+                "Required and must be non-empty — the contract rejects a blank one (u440)."),
         },
-    }, async ({ proposalId, support }) => {
+    }, async ({ proposalId, support, rationale }) => {
         try {
             const account = await getLegionAccount();
             const [params, story, storyPhase, weight, existingVote, clock] = await Promise.all([
@@ -808,6 +871,11 @@ export function registerLegionTools(server) {
                 getVoteRecord(proposalId, account.address),
                 getClockHeight(),
             ]);
+            if (rationale.trim().length === 0) {
+                return createErrorResponse(new Error(`The rationale cannot be blank (u440). Pass a sentence on why this piece is ` +
+                    `or is not worth paying for. Nothing was signed.`));
+            }
+            assertAscii(rationale, "rationale", MAX_RATIONALE_LENGTH);
             if (!story) {
                 return createErrorResponse(new Error(`No proposal ${proposalId} in this legion (u404).`));
             }
@@ -817,43 +885,53 @@ export function registerLegionTools(server) {
             }
             if (account.address === story.proposer) {
                 return createErrorResponse(new Error(`You are the proposer of ${proposalId} and cannot vote on your own piece (u423). ` +
-                    `You may still legion_veto it to withdraw it.`));
+                    `This era has no veto either, so there is no way to withdraw it — let it run ` +
+                    `or let the conclude window lapse.`));
             }
             if (storyPhase === "pending") {
-                const opensAt = story.createdAt + params.votingDelay;
+                const opensAt = story.createdAt + params.voteDelay;
                 return createErrorResponse(new Error(`Proposal ${proposalId} is still pending — voting opens at height ${opensAt}, ` +
                     `and the tip is ${clock.height} (${opensAt - clock.height} blocks to go, u436).`));
             }
             if (storyPhase !== "voting") {
                 return createErrorResponse(new Error(`Proposal ${proposalId} is in the "${storyPhase}" phase — voting is closed (u407). ` +
-                    (storyPhase === "veto"
-                        ? "You can still legion_veto it."
-                        : "Nothing was signed.")));
+                    `Nothing was signed.`));
             }
-            if (num(weight) < params.minWeight) {
-                return createErrorResponse(new Error(`Your weight is ${num(weight)}, below the minWeight of ${params.minWeight} (u401). ` +
-                    `Call legion_contribute first.`));
+            if (num(weight) < params.minWeightToAct) {
+                return createErrorResponse(new Error(`Your weight is ${num(weight)}, below the minWeightToAct of ` +
+                    `${params.minWeightToAct} (u401). Call legion_contribute first.`));
             }
             const result = await callContract(account, {
                 contractAddress: GOV_ADDRESS,
                 contractName: GOV_NAME,
                 functionName: "vote",
-                functionArgs: [uintCV(proposalId), boolCV(support)],
+                functionArgs: [
+                    uintCV(proposalId),
+                    boolCV(support),
+                    stringAsciiCV(rationale),
+                ],
                 // Voting moves nothing.
                 postConditionMode: PostConditionMode.Deny,
                 postConditions: [],
             });
+            const yesAfter = support ? story.yesWeight + num(weight) : story.yesWeight;
+            const yesNeeded = story.payout * params.yesMultiple;
             return createJsonResponse({
                 success: true,
                 txid: result.txid,
                 explorerUrl: explorerUrl(result.txid),
                 proposalId,
+                era: LIVE_ERA.version,
                 support,
+                rationale,
                 votedWith: num(weight),
                 voter: account.address,
                 network: LEGION_NETWORK,
                 voteEnd: story.voteEnd,
                 blocksLeftToVote: story.voteEnd - clock.height,
+                yesWeightAfter: yesAfter,
+                yesWeightNeeded: yesNeeded,
+                yesWeightMet: yesAfter >= yesNeeded,
                 note: "One vote per principal — this cannot be changed or withdrawn.",
             });
         }
@@ -862,82 +940,13 @@ export function registerLegionTools(server) {
         }
     });
     // ==========================================================================
-    // legion_veto
-    // ==========================================================================
-    server.registerTool("legion_veto", {
-        description: "Object during the veto window. At veto quorum the piece fails regardless of the vote — " +
-            "the backstop against a plagiarised or junk inscription that slipped past. A proposer " +
-            "may veto their own piece, which withdraws it.\n\n" +
-            "Pre-flights the window and your weight. Requires an unlocked wallet.",
-        inputSchema: {
-            proposalId: z.number().int().positive().describe("The proposal id"),
-        },
-    }, async ({ proposalId }) => {
-        try {
-            const account = await getLegionAccount();
-            const [params, story, storyPhase, weight, existingVeto, clock] = await Promise.all([
-                getParams(),
-                getStory(proposalId),
-                getPhase(proposalId),
-                readGov("get-weight", [principalCV(account.address)]),
-                getVetoRecord(proposalId, account.address),
-                getClockHeight(),
-            ]);
-            if (!story) {
-                return createErrorResponse(new Error(`No proposal ${proposalId} in this legion (u404).`));
-            }
-            if (existingVeto) {
-                return createErrorResponse(new Error(`You already vetoed proposal ${proposalId} with ${existingVeto.weight} weight (u425).`));
-            }
-            if (storyPhase !== "veto") {
-                const vetoEnd = story.voteEnd + params.vetoWindow;
-                return createErrorResponse(new Error(`Proposal ${proposalId} is in the "${storyPhase}" phase — the veto window is ` +
-                    `[${story.voteEnd}, ${vetoEnd}) and the tip is ${clock.height} (u424). ` +
-                    (storyPhase === "voting"
-                        ? "Vote no with legion_vote while voting is still open."
-                        : "Nothing was signed.")));
-            }
-            if (num(weight) < params.minWeight) {
-                return createErrorResponse(new Error(`Your weight is ${num(weight)}, below the minWeight of ${params.minWeight} (u401).`));
-            }
-            const result = await callContract(account, {
-                contractAddress: GOV_ADDRESS,
-                contractName: GOV_NAME,
-                functionName: "veto",
-                functionArgs: [uintCV(proposalId)],
-                postConditionMode: PostConditionMode.Deny,
-                postConditions: [],
-            });
-            const vetoWeightAfter = story.vetoWeight + num(weight);
-            const vetoPctAfter = story.eligibleSnapshot > 0
-                ? Math.floor((vetoWeightAfter * 100) / story.eligibleSnapshot)
-                : 0;
-            return createJsonResponse({
-                success: true,
-                txid: result.txid,
-                explorerUrl: explorerUrl(result.txid),
-                proposalId,
-                vetoedWith: num(weight),
-                vetoWeightAfter,
-                vetoPctAfter,
-                vetoQuorumPct: params.vetoQuorum,
-                wouldBlock: vetoPctAfter >= params.vetoQuorum,
-                network: LEGION_NETWORK,
-                vetoEnd: story.voteEnd + params.vetoWindow,
-            });
-        }
-        catch (error) {
-            return legionError(error);
-        }
-    });
-    // ==========================================================================
     // legion_conclude
     // ==========================================================================
     server.registerTool("legion_conclude", {
-        description: "Settle a proposal and, if it passed, pay the proposer the draw. Permissionless — " +
-            "anyone may call it, and someone must.\n\n" +
+        description: "Settle a proposal and, if it passed, pay the proposer. Permissionless — anyone may " +
+            "call it, and someone must. Conclude opens the moment voting closes.\n\n" +
             "A piece nobody concludes inside its window EXPIRES, pays no one, and can never be " +
-            "concluded after. Concluding late pays what concluding early would; the draw was " +
+            "concluded after. Concluding late pays what concluding early would; the payout was " +
             "snapshotted at propose time.\n\n" +
             "Requires an unlocked wallet — caller pays gas, proposer gets the payout.",
         inputSchema: {
@@ -963,14 +972,14 @@ export function registerLegionTools(server) {
             }
             if (storyPhase === "expired") {
                 return createErrorResponse(new Error(`Proposal ${proposalId} has expired — its conclude window closed at height ` +
-                    `${story.voteEnd + params.vetoWindow + params.concludeWindow} and the tip is ` +
-                    `${clock.height} (u435). It can no longer be concluded and pays nobody. ` +
-                    `The proposer's bond has already released itself.`));
+                    `${story.voteEnd + params.concludeWindow} and the tip is ${clock.height} ` +
+                    `(u435). It can no longer be concluded and pays nobody. The proposer's weight ` +
+                    `lock has already released itself.`));
             }
             if (storyPhase !== "concludable") {
-                const vetoEnd = story.voteEnd + params.vetoWindow;
                 return createErrorResponse(new Error(`Proposal ${proposalId} is in the "${storyPhase}" phase — conclude opens at height ` +
-                    `${vetoEnd} and the tip is ${clock.height} (${vetoEnd - clock.height} blocks to go, u408).`));
+                    `${story.voteEnd} and the tip is ${clock.height} ` +
+                    `(${story.voteEnd - clock.height} blocks to go, u408).`));
             }
             const prediction = predictOutcome(story, params, num(pool), clock.height);
             const result = await callContract(account, {
@@ -979,12 +988,12 @@ export function registerLegionTools(server) {
                 functionName: "conclude",
                 functionArgs: [uintCV(proposalId)],
                 postConditionMode: PostConditionMode.Deny,
-                // The treasury pays either the whole snapshotted draw or nothing at
+                // The treasury pays either the whole snapshotted payout or nothing at
                 // all, and the outcome is decided on chain at mining time. A cap of
-                // the draw covers both, and covers nothing larger.
+                // the payout covers both, and covers nothing larger.
                 postConditions: [
-                    Pc.principal(LEGION_TREASURY_CONTRACT)
-                        .willSendLte(story.draw)
+                    Pc.principal(LIVE_ERA.treasury)
+                        .willSendLte(story.payout)
                         .ft(token.contract, token.assetName),
                 ],
             });
@@ -1002,9 +1011,9 @@ export function registerLegionTools(server) {
                 tally: {
                     yes: story.yesWeight,
                     no: story.noWeight,
-                    veto: story.vetoWeight,
                     cast: prediction.cast,
-                    eligible: story.eligibleSnapshot,
+                    yesNeeded: prediction.yesWeightRequired,
+                    totalWeightAtOpen: story.totalWeightAtOpen,
                     voters: story.voterCount,
                 },
                 note: "Expected outcome is computed from the tally as of now with the contract's own " +
@@ -1022,10 +1031,11 @@ export function registerLegionTools(server) {
         description: "Inscribe a news piece to a Bitcoin ordinal as markdown — STEP 1, the commit.\n\n" +
             "Content type is text/markdown; the title is prepended as an H1 unless the body already " +
             "starts with one.\n\n" +
-            `SPENDS REAL BITCOIN, on the Bitcoin network NETWORK names (currently ${NETWORK}) — ` +
-            `not the Stacks ${LEGION_NETWORK} the rest of the legion_* tools use. A mainnet ` +
-            "inscription therefore needs `confirmMainnetSpend: true`; without it the tool prices " +
-            "the piece and refuses, so real BTC is never spent by accident.\n\n" +
+            `SPENDS REAL BITCOIN on L1, on the Bitcoin network NETWORK names (currently ${NETWORK}) ` +
+            `— this is native BTC from your UTXOs, not the sBTC the rest of the legion moves on ` +
+            `Stacks ${LEGION_NETWORK}. A mainnet inscription needs \`confirmMainnetSpend: true\`; ` +
+            "without it the tool prices the piece and refuses, so real BTC is never spent by " +
+            "accident.\n\n" +
             "Optional `parentInscriptionId` files the piece as a child of a parent you own, binding " +
             "your pieces to one inscribed identity. That is authorship, not originality.\n\n" +
             "Pre-flights content size, fee estimate, parent ownership, funding and network before " +
@@ -1070,9 +1080,9 @@ export function registerLegionTools(server) {
     }, async ({ title, body, parentInscriptionId, dryRun, confirmMainnetSpend, allowNonMainnet, feeRate }) => {
         try {
             // A testnet inscription is almost always a misconfiguration here: the
-            // legion's governance is testnet but its links are read on mainnet
-            // ordinals.com, so the piece would be unreadable to every voter. A JSON
-            // warning field was too easy to miss for something that costs sats.
+            // link is read on mainnet ordinals.com, so the piece would be unreadable
+            // to every voter. A JSON warning field was too easy to miss for
+            // something that costs sats.
             if (NETWORK !== "mainnet" && !allowNonMainnet) {
                 return createErrorResponse(new Error(`Bitcoin network is ${NETWORK}, and ordinals.com serves mainnet inscriptions ` +
                     `only — voters could not open the link this produces. Set NETWORK=mainnet, ` +
@@ -1191,18 +1201,16 @@ export function registerLegionTools(server) {
                     nextStep: "Nothing was signed. Re-call without dryRun to broadcast the commit.",
                 });
             }
-            // The legion itself is testnet, so an agent working through it has no
-            // reason to expect real money to move. Inscription is the one step that
-            // does, and it cannot be moved off mainnet (ordinals.com indexes mainnet
-            // only), so the cost is quoted and consent taken instead.
+            // This is native BTC leaving L1 UTXOs, which the SPEND_LIMIT_* sats rail
+            // does not meter on this path — so consent is taken explicitly instead,
+            // with the exact cost quoted.
             if (NETWORK === "mainnet" && !confirmMainnetSpend) {
                 const total = commitResult.fee + commitResult.revealAmount;
                 return createErrorResponse(new Error(`This would spend ${total} sats of REAL BITCOIN on mainnet — ` +
                     `${commitResult.fee} commit fee plus ${commitResult.revealAmount} locked for ` +
-                    `the reveal. The legion's governance is Stacks ${LEGION_NETWORK}, but the ` +
-                    `inscription is mainnet Bitcoin because ordinals.com indexes mainnet only. ` +
-                    `Nothing was signed. Re-call with confirmMainnetSpend: true to proceed, or ` +
-                    `dryRun: true for the full breakdown.`));
+                    `the reveal. This is native L1 BTC from your UTXOs, separate from the sBTC ` +
+                    `the legion's governance moves on Stacks. Nothing was signed. Re-call with ` +
+                    `confirmMainnetSpend: true to proceed, or dryRun: true for the full breakdown.`));
             }
             const commitSigned = signBtcTransaction(commitResult.tx, account.btcPrivateKey);
             const commitTxid = await mempoolApi.broadcastTransaction(commitSigned.txHex);