@spectratools/assembly-cli 0.9.0 → 0.10.0

package/dist/cli.js

@@ -5242,11 +5242,40 @@ council.command("withdraw-refund", {
 });
 
 // src/commands/forum.ts
+import { TxError } from "@spectratools/tx-shared";
 import { Cli as Cli2, z as z3 } from "incur";
 var env2 = z3.object({
   ABSTRACT_RPC_URL: z3.string().optional().describe("Abstract RPC URL override")
 });
+var commentEnv = env2.extend({
+  PRIVATE_KEY: z3.string().optional().describe("Private key (required only when posting a comment via --body)")
+});
 var timestampOutput2 = z3.union([z3.number(), z3.string()]);
+var txResultOutput2 = z3.union([
+  z3.object({
+    status: z3.literal("success"),
+    hash: z3.string(),
+    blockNumber: z3.number(),
+    gasUsed: z3.string(),
+    from: z3.string(),
+    to: z3.string().nullable(),
+    effectiveGasPrice: z3.string().optional()
+  }),
+  z3.object({
+    status: z3.literal("reverted"),
+    hash: z3.string(),
+    blockNumber: z3.number(),
+    gasUsed: z3.string(),
+    from: z3.string(),
+    to: z3.string().nullable(),
+    effectiveGasPrice: z3.string().optional()
+  }),
+  z3.object({
+    status: z3.literal("dry-run"),
+    estimatedGas: z3.string(),
+    simulationResult: z3.unknown()
+  })
+]);
 function decodeThread(value) {
   const [id, kind, author, createdAt, category, title, body, proposalId, petitionId] = value;
   return {
@@ -5356,7 +5385,7 @@ forum.command("threads", {
           description: "Inspect or comment:",
           commands: [
             { command: "forum thread", args: { id: "<id>" } },
-            { command: "forum post-comment", args: { id: "<id>" } }
+            { command: "forum post-comment", args: { threadId: "<id>" } }
           ]
         }
       }
@@ -5451,34 +5480,395 @@ forum.command("comments", {
   }
 });
 forum.command("comment", {
-  description: "Get one comment by comment id.",
+  description: "Get one comment by id, or post to a thread when --body is provided.",
   args: z3.object({
-    id: z3.coerce.number().int().positive().describe("Comment id (1-indexed)")
+    id: z3.coerce.number().int().positive().describe("Comment id (read) or thread id (write)")
   }),
-  env: env2,
+  options: writeOptions.extend({
+    body: z3.string().min(1).optional().describe("Comment body (write mode)"),
+    "parent-id": z3.coerce.number().int().nonnegative().default(0).describe("Optional parent comment id for threaded replies (write mode)")
+  }),
+  env: commentEnv,
   output: z3.record(z3.string(), z3.unknown()),
-  examples: [{ args: { id: 1 }, description: "Fetch comment #1" }],
+  examples: [
+    { args: { id: 1 }, description: "Fetch comment #1" },
+    {
+      args: { id: 1 },
+      options: { body: "I support this proposal." },
+      description: "Post a new comment on thread #1"
+    }
+  ],
   async run(c) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
-    const commentCount = await client.readContract({
-      abi: forumAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.forum,
-      functionName: "commentCount"
-    });
-    if (c.args.id > Number(commentCount)) {
+    if (!c.options.body) {
+      const commentCount2 = await client.readContract({
+        abi: forumAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        functionName: "commentCount"
+      });
+      if (c.args.id > Number(commentCount2)) {
+        return c.error({
+          code: "OUT_OF_RANGE",
+          message: `Comment id ${c.args.id} does not exist (commentCount: ${commentCount2})`,
+          retryable: false
+        });
+      }
+      const commentTuple = await client.readContract({
+        abi: forumAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        functionName: "comments",
+        args: [BigInt(c.args.id)]
+      });
+      return c.ok(jsonSafe(decodeComment(commentTuple)));
+    }
+    if (!c.env.PRIVATE_KEY) {
+      return c.error({
+        code: "MISSING_PRIVATE_KEY",
+        message: "PRIVATE_KEY is required when posting a comment.",
+        retryable: false
+      });
+    }
+    const account = resolveAccount({ PRIVATE_KEY: c.env.PRIVATE_KEY });
+    const [activeMember, threadCount, commentCount] = await Promise.all([
+      client.readContract({
+        abi: registryAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.registry,
+        functionName: "isActive",
+        args: [account.address]
+      }),
+      client.readContract({
+        abi: forumAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        functionName: "threadCount"
+      }),
+      client.readContract({
+        abi: forumAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        functionName: "commentCount"
+      })
+    ]);
+    if (!activeMember) {
+      return c.error({
+        code: "NOT_ACTIVE_MEMBER",
+        message: `Address ${toChecksum(account.address)} is not an active Assembly member.`,
+        retryable: false
+      });
+    }
+    if (c.args.id > Number(threadCount)) {
       return c.error({
         code: "OUT_OF_RANGE",
-        message: `Comment id ${c.args.id} does not exist (commentCount: ${commentCount})`,
+        message: `Thread id ${c.args.id} does not exist (threadCount: ${threadCount})`,
         retryable: false
       });
     }
-    const commentTuple = await client.readContract({
-      abi: forumAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.forum,
-      functionName: "comments",
-      args: [BigInt(c.args.id)]
-    });
-    return c.ok(jsonSafe(decodeComment(commentTuple)));
+    if (c.options["parent-id"] > Number(commentCount)) {
+      return c.error({
+        code: "OUT_OF_RANGE",
+        message: `Parent comment id ${c.options["parent-id"]} does not exist (commentCount: ${commentCount})`,
+        retryable: false
+      });
+    }
+    const expectedCommentId = Number(commentCount) + 1;
+    try {
+      const txResult = await assemblyWriteTx({
+        env: {
+          PRIVATE_KEY: c.env.PRIVATE_KEY,
+          ABSTRACT_RPC_URL: c.env.ABSTRACT_RPC_URL
+        },
+        options: c.options,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        abi: forumAbi,
+        functionName: "postComment",
+        args: [BigInt(c.args.id), BigInt(c.options["parent-id"]), c.options.body]
+      });
+      return c.ok({
+        author: toChecksum(account.address),
+        threadId: c.args.id,
+        parentId: c.options["parent-id"],
+        expectedCommentId,
+        tx: txResult
+      });
+    } catch (error) {
+      if (error instanceof TxError) {
+        return c.error({
+          code: error.code,
+          message: error.message,
+          retryable: error.code === "NONCE_CONFLICT"
+        });
+      }
+      throw error;
+    }
+  }
+});
+forum.command("post", {
+  description: "Create a new discussion thread in the forum.",
+  hint: "Requires PRIVATE_KEY environment variable for signing.",
+  options: writeOptions.extend({
+    category: z3.string().min(1).describe("Thread category label (e.g., general, governance)"),
+    title: z3.string().min(1).describe("Thread title"),
+    body: z3.string().min(1).describe("Thread body")
+  }),
+  env: writeEnv,
+  output: z3.object({
+    author: z3.string(),
+    category: z3.string(),
+    title: z3.string(),
+    expectedThreadId: z3.number(),
+    tx: txResultOutput2
+  }),
+  examples: [
+    {
+      options: {
+        category: "general",
+        title: "Roadmap discussion",
+        body: "Should we prioritize treasury automation in Q2?"
+      },
+      description: "Post a new discussion thread"
+    }
+  ],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const account = resolveAccount(c.env);
+    const [activeMember, threadCountBefore] = await Promise.all([
+      client.readContract({
+        abi: registryAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.registry,
+        functionName: "isActive",
+        args: [account.address]
+      }),
+      client.readContract({
+        abi: forumAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        functionName: "threadCount"
+      })
+    ]);
+    if (!activeMember) {
+      return c.error({
+        code: "NOT_ACTIVE_MEMBER",
+        message: `Address ${toChecksum(account.address)} is not an active Assembly member.`,
+        retryable: false
+      });
+    }
+    const expectedThreadId = Number(threadCountBefore) + 1;
+    try {
+      const txResult = await assemblyWriteTx({
+        env: c.env,
+        options: c.options,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        abi: forumAbi,
+        functionName: "postDiscussionThread",
+        args: [c.options.category, c.options.title, c.options.body]
+      });
+      return c.ok({
+        author: toChecksum(account.address),
+        category: c.options.category,
+        title: c.options.title,
+        expectedThreadId,
+        tx: txResult
+      });
+    } catch (error) {
+      if (error instanceof TxError) {
+        return c.error({
+          code: error.code,
+          message: error.message,
+          retryable: error.code === "NONCE_CONFLICT"
+        });
+      }
+      throw error;
+    }
+  }
+});
+forum.command("post-comment", {
+  description: "Post a comment to a forum thread.",
+  hint: "Requires PRIVATE_KEY environment variable for signing.",
+  args: z3.object({
+    threadId: z3.coerce.number().int().positive().describe("Thread id to comment on")
+  }),
+  options: writeOptions.extend({
+    body: z3.string().min(1).describe("Comment body"),
+    "parent-id": z3.coerce.number().int().nonnegative().default(0).describe("Optional parent comment id for threaded replies")
+  }),
+  env: writeEnv,
+  output: z3.object({
+    author: z3.string(),
+    threadId: z3.number(),
+    parentId: z3.number(),
+    expectedCommentId: z3.number(),
+    tx: txResultOutput2
+  }),
+  examples: [
+    {
+      args: { threadId: 1 },
+      options: {
+        body: "Appreciate the update \u2014 support from me."
+      },
+      description: "Post a comment on thread #1"
+    }
+  ],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const account = resolveAccount(c.env);
+    const [activeMember, threadCount, commentCount] = await Promise.all([
+      client.readContract({
+        abi: registryAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.registry,
+        functionName: "isActive",
+        args: [account.address]
+      }),
+      client.readContract({
+        abi: forumAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        functionName: "threadCount"
+      }),
+      client.readContract({
+        abi: forumAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        functionName: "commentCount"
+      })
+    ]);
+    if (!activeMember) {
+      return c.error({
+        code: "NOT_ACTIVE_MEMBER",
+        message: `Address ${toChecksum(account.address)} is not an active Assembly member.`,
+        retryable: false
+      });
+    }
+    if (c.args.threadId > Number(threadCount)) {
+      return c.error({
+        code: "OUT_OF_RANGE",
+        message: `Thread id ${c.args.threadId} does not exist (threadCount: ${threadCount})`,
+        retryable: false
+      });
+    }
+    if (c.options["parent-id"] > Number(commentCount)) {
+      return c.error({
+        code: "OUT_OF_RANGE",
+        message: `Parent comment id ${c.options["parent-id"]} does not exist (commentCount: ${commentCount})`,
+        retryable: false
+      });
+    }
+    const expectedCommentId = Number(commentCount) + 1;
+    try {
+      const txResult = await assemblyWriteTx({
+        env: c.env,
+        options: c.options,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        abi: forumAbi,
+        functionName: "postComment",
+        args: [BigInt(c.args.threadId), BigInt(c.options["parent-id"]), c.options.body]
+      });
+      return c.ok({
+        author: toChecksum(account.address),
+        threadId: c.args.threadId,
+        parentId: c.options["parent-id"],
+        expectedCommentId,
+        tx: txResult
+      });
+    } catch (error) {
+      if (error instanceof TxError) {
+        return c.error({
+          code: error.code,
+          message: error.message,
+          retryable: error.code === "NONCE_CONFLICT"
+        });
+      }
+      throw error;
+    }
+  }
+});
+forum.command("sign-petition", {
+  description: "Sign an existing petition as an active member.",
+  hint: "Requires PRIVATE_KEY environment variable for signing.",
+  args: z3.object({
+    petitionId: z3.coerce.number().int().positive().describe("Petition id (1-indexed)")
+  }),
+  options: writeOptions,
+  env: writeEnv,
+  output: z3.object({
+    signer: z3.string(),
+    petitionId: z3.number(),
+    expectedSignatures: z3.number(),
+    tx: txResultOutput2
+  }),
+  examples: [{ args: { petitionId: 1 }, description: "Sign petition #1" }],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const account = resolveAccount(c.env);
+    const [activeMember, petitionCount] = await Promise.all([
+      client.readContract({
+        abi: registryAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.registry,
+        functionName: "isActive",
+        args: [account.address]
+      }),
+      client.readContract({
+        abi: forumAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        functionName: "petitionCount"
+      })
+    ]);
+    if (!activeMember) {
+      return c.error({
+        code: "NOT_ACTIVE_MEMBER",
+        message: `Address ${toChecksum(account.address)} is not an active Assembly member.`,
+        retryable: false
+      });
+    }
+    if (c.args.petitionId > Number(petitionCount)) {
+      return c.error({
+        code: "OUT_OF_RANGE",
+        message: `Petition id ${c.args.petitionId} does not exist (petitionCount: ${petitionCount})`,
+        retryable: false
+      });
+    }
+    const [alreadySigned, petitionTuple] = await Promise.all([
+      client.readContract({
+        abi: forumAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        functionName: "hasSignedPetition",
+        args: [BigInt(c.args.petitionId), account.address]
+      }),
+      client.readContract({
+        abi: forumAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        functionName: "petitions",
+        args: [BigInt(c.args.petitionId)]
+      })
+    ]);
+    if (alreadySigned) {
+      return c.error({
+        code: "ALREADY_SIGNED",
+        message: `Address ${toChecksum(account.address)} has already signed petition #${c.args.petitionId}.`,
+        retryable: false
+      });
+    }
+    const petition = decodePetition(petitionTuple);
+    const expectedSignatures = petition.signatures + 1;
+    try {
+      const txResult = await assemblyWriteTx({
+        env: c.env,
+        options: c.options,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        abi: forumAbi,
+        functionName: "signPetition",
+        args: [BigInt(c.args.petitionId)]
+      });
+      return c.ok({
+        signer: toChecksum(account.address),
+        petitionId: c.args.petitionId,
+        expectedSignatures,
+        tx: txResult
+      });
+    } catch (error) {
+      if (error instanceof TxError) {
+        return c.error({
+          code: error.code,
+          message: error.message,
+          retryable: error.code === "NONCE_CONFLICT"
+        });
+      }
+      throw error;
+    }
   }
 });
 forum.command("petitions", {
@@ -5622,7 +6012,7 @@ forum.command("stats", {
 });
 
 // src/commands/governance.ts
-import { TxError } from "@spectratools/tx-shared";
+import { TxError as TxError2 } from "@spectratools/tx-shared";
 import { Cli as Cli3, z as z4 } from "incur";
 var env3 = z4.object({
   ABSTRACT_RPC_URL: z4.string().optional().describe("Abstract RPC URL override")
@@ -5969,7 +6359,7 @@ governance.command("params", {
     });
   }
 });
-var txResultOutput2 = z4.union([
+var txResultOutput3 = z4.union([
   z4.object({
     status: z4.enum(["success", "reverted"]),
     hash: z4.string(),
@@ -5999,7 +6389,7 @@ governance.command("vote", {
     proposalTitle: z4.string(),
     support: z4.enum(["for", "against", "abstain"]),
     supportValue: z4.number(),
-    tx: txResultOutput2
+    tx: txResultOutput3
   }),
   examples: [
     {
@@ -6063,7 +6453,7 @@ governance.command("vote", {
         tx: txResult
       });
     } catch (error) {
-      if (error instanceof TxError) {
+      if (error instanceof TxError2) {
         return c.error({
           code: error.code,
           message: error.message,
@@ -6094,7 +6484,7 @@ governance.command("propose", {
     title: z4.string(),
     description: z4.string(),
     expectedProposalId: z4.number(),
-    tx: txResultOutput2
+    tx: txResultOutput3
   }),
   examples: [
     {
@@ -6168,7 +6558,7 @@ governance.command("propose", {
         tx: txResult
       });
     } catch (error) {
-      if (error instanceof TxError) {
+      if (error instanceof TxError2) {
         return c.error({
           code: error.code,
           message: error.message,
@@ -6191,7 +6581,7 @@ governance.command("queue", {
     proposalId: z4.number(),
     proposalTitle: z4.string(),
     statusBefore: z4.string(),
-    tx: txResultOutput2
+    tx: txResultOutput3
   }),
   examples: [
     {
@@ -6256,7 +6646,7 @@ governance.command("queue", {
         tx: txResult
       });
     } catch (error) {
-      if (error instanceof TxError) {
+      if (error instanceof TxError2) {
         return c.error({
           code: error.code,
           message: error.message,
@@ -6279,7 +6669,7 @@ governance.command("execute", {
     proposalId: z4.number(),
     proposalTitle: z4.string(),
     timelockEndsAt: timestampOutput3,
-    tx: txResultOutput2
+    tx: txResultOutput3
   }),
   examples: [
     {
@@ -6330,7 +6720,7 @@ governance.command("execute", {
         tx: txResult
       });
     } catch (error) {
-      if (error instanceof TxError) {
+      if (error instanceof TxError2) {
         return c.error({
           code: error.code,
           message: error.message,
@@ -6343,7 +6733,7 @@ governance.command("execute", {
 });
 
 // src/commands/members.ts
-import { TxError as TxError2 } from "@spectratools/tx-shared";
+import { TxError as TxError3 } from "@spectratools/tx-shared";
 import { Cli as Cli4, z as z5 } from "incur";
 var DEFAULT_MEMBER_SNAPSHOT_URL = "https://www.theaiassembly.org/api/indexer/members";
 var REGISTERED_EVENT_SCAN_STEP = 100000n;
@@ -6836,7 +7226,7 @@ members.command("register", {
         } : void 0
       );
     } catch (error) {
-      if (error instanceof TxError2 && error.code === "INSUFFICIENT_FUNDS") {
+      if (error instanceof TxError3 && error.code === "INSUFFICIENT_FUNDS") {
         return c.error({
           code: "INSUFFICIENT_FUNDS",
           message: `Insufficient funds to register. Required fee: ${eth(fee)} (${fee} wei). ${error.message}`,
@@ -6887,7 +7277,7 @@ members.command("heartbeat", {
         } : void 0
       );
     } catch (error) {
-      if (error instanceof TxError2 && error.code === "INSUFFICIENT_FUNDS") {
+      if (error instanceof TxError3 && error.code === "INSUFFICIENT_FUNDS") {
         return c.error({
           code: "INSUFFICIENT_FUNDS",
           message: `Insufficient funds for heartbeat. Required fee: ${eth(fee)} (${fee} wei). ${error.message}`,
@@ -6938,7 +7328,7 @@ members.command("renew", {
         } : void 0
       );
     } catch (error) {
-      if (error instanceof TxError2 && error.code === "INSUFFICIENT_FUNDS") {
+      if (error instanceof TxError3 && error.code === "INSUFFICIENT_FUNDS") {
         return c.error({
           code: "INSUFFICIENT_FUNDS",
           message: `Insufficient funds to renew. Required fee: ${eth(fee)} (${fee} wei). ${error.message}`,
@@ -6951,11 +7341,38 @@ members.command("renew", {
 });
 
 // src/commands/treasury.ts
+import { TxError as TxError4 } from "@spectratools/tx-shared";
 import { Cli as Cli5, z as z6 } from "incur";
+import { encodeAbiParameters, parseUnits, zeroAddress } from "viem";
 var env5 = z6.object({
   ABSTRACT_RPC_URL: z6.string().optional().describe("Abstract RPC URL override")
 });
 var timestampOutput5 = z6.union([z6.number(), z6.string()]);
+var txResultOutput4 = z6.union([
+  z6.object({
+    status: z6.literal("success"),
+    hash: z6.string(),
+    blockNumber: z6.number(),
+    gasUsed: z6.string(),
+    from: z6.string(),
+    to: z6.string().nullable(),
+    effectiveGasPrice: z6.string().optional()
+  }),
+  z6.object({
+    status: z6.literal("reverted"),
+    hash: z6.string(),
+    blockNumber: z6.number(),
+    gasUsed: z6.string(),
+    from: z6.string(),
+    to: z6.string().nullable(),
+    effectiveGasPrice: z6.string().optional()
+  }),
+  z6.object({
+    status: z6.literal("dry-run"),
+    estimatedGas: z6.string(),
+    simulationResult: z6.unknown()
+  })
+]);
 var treasury = Cli5.create("treasury", {
   description: "Inspect treasury balances, execution status, and spend controls."
 });
@@ -7078,6 +7495,192 @@ treasury.command("executed", {
     return c.ok({ proposalId: c.args.proposalId, executed });
   }
 });
+treasury.command("propose-spend", {
+  description: "Create a council proposal that spends treasury funds via TreasuryTransferIntentModule.",
+  hint: "Requires PRIVATE_KEY environment variable for signing.",
+  options: writeOptions.extend({
+    token: z6.string().describe("Token address to spend (use 0x0000000000000000000000000000000000000000 for ETH)"),
+    recipient: z6.string().describe("Recipient address"),
+    amount: z6.string().describe("Token amount as decimal string (human units)"),
+    decimals: z6.coerce.number().int().min(0).max(36).default(18).describe("Token decimals used to parse --amount (default: 18)"),
+    title: z6.string().min(1).describe("Proposal title"),
+    description: z6.string().min(1).describe("Proposal description"),
+    category: z6.string().default("treasury").describe("Forum category label for this proposal"),
+    "risk-tier": z6.coerce.number().int().min(0).max(3).default(3).describe("Max allowed risk tier in intent constraints (0-3, default: 3)")
+  }),
+  env: writeEnv,
+  output: z6.object({
+    proposer: z6.string(),
+    category: z6.string(),
+    token: z6.string(),
+    recipient: z6.string(),
+    amount: z6.string(),
+    amountWei: z6.string(),
+    expectedProposalId: z6.number(),
+    expectedThreadId: z6.number(),
+    tx: txResultOutput4
+  }),
+  examples: [
+    {
+      options: {
+        token: "0x0000000000000000000000000000000000000000",
+        recipient: "0x00000000000000000000000000000000000000b0",
+        amount: "0.5",
+        title: "Fund grants round",
+        description: "Allocate 0.5 ETH from treasury to the grants multisig."
+      },
+      description: "Propose a treasury spend transfer"
+    }
+  ],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const account = resolveAccount(c.env);
+    const token = toChecksum(c.options.token);
+    const recipient = toChecksum(c.options.recipient);
+    let amountWei;
+    try {
+      amountWei = parseUnits(c.options.amount, c.options.decimals);
+    } catch {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: `Invalid amount "${c.options.amount}" for decimals=${c.options.decimals}.`,
+        retryable: false
+      });
+    }
+    if (amountWei <= 0n) {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: "--amount must be greater than zero.",
+        retryable: false
+      });
+    }
+    const [activeMember, isCouncilMember, transferModule, proposalCount, threadCount, whitelisted] = await Promise.all([
+      client.readContract({
+        abi: registryAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.registry,
+        functionName: "isActive",
+        args: [account.address]
+      }),
+      client.readContract({
+        abi: councilSeatsAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.councilSeats,
+        functionName: "isCouncilMember",
+        args: [account.address]
+      }),
+      client.readContract({
+        abi: treasuryAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.treasury,
+        functionName: "treasuryTransferModule"
+      }),
+      client.readContract({
+        abi: governanceAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.governance,
+        functionName: "proposalCount"
+      }),
+      client.readContract({
+        abi: forumAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        functionName: "threadCount"
+      }),
+      token === zeroAddress ? Promise.resolve(true) : client.readContract({
+        abi: treasuryAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.treasury,
+        functionName: "isAssetWhitelisted",
+        args: [token]
+      })
+    ]);
+    if (!activeMember) {
+      return c.error({
+        code: "NOT_ACTIVE_MEMBER",
+        message: `Address ${toChecksum(account.address)} is not an active Assembly member.`,
+        retryable: false
+      });
+    }
+    if (!isCouncilMember) {
+      return c.error({
+        code: "NOT_COUNCIL_MEMBER",
+        message: `Address ${toChecksum(account.address)} is not an active council member and cannot create treasury spend proposals.`,
+        retryable: false
+      });
+    }
+    if (!whitelisted) {
+      return c.error({
+        code: "ASSET_NOT_WHITELISTED",
+        message: `Token ${token} is not treasury-whitelisted for spending.`,
+        retryable: false
+      });
+    }
+    const transferModuleAllowed = await client.readContract({
+      abi: treasuryAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.treasury,
+      functionName: "isIntentModuleAllowed",
+      args: [transferModule]
+    });
+    if (!transferModuleAllowed) {
+      return c.error({
+        code: "INTENT_MODULE_DISABLED",
+        message: `Treasury transfer intent module ${toChecksum(transferModule)} is currently disabled.`,
+        retryable: false
+      });
+    }
+    const moduleData = encodeAbiParameters(
+      [
+        { name: "asset", type: "address" },
+        { name: "recipient", type: "address" },
+        { name: "amount", type: "uint256" }
+      ],
+      [token, recipient, amountWei]
+    );
+    const proposalInput = {
+      kind: 2,
+      title: c.options.title,
+      description: c.options.description,
+      intentSteps: [
+        {
+          module: transferModule,
+          moduleData
+        }
+      ],
+      intentConstraints: {
+        deadline: 0,
+        maxAllowedRiskTier: c.options["risk-tier"]
+      },
+      configUpdates: []
+    };
+    const expectedProposalId = Number(proposalCount) + 1;
+    const expectedThreadId = Number(threadCount) + 1;
+    try {
+      const txResult = await assemblyWriteTx({
+        env: c.env,
+        options: c.options,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        abi: forumAbi,
+        functionName: "createCouncilProposal",
+        args: [c.options.category, proposalInput]
+      });
+      return c.ok({
+        proposer: toChecksum(account.address),
+        category: c.options.category,
+        token,
+        recipient,
+        amount: c.options.amount,
+        amountWei: amountWei.toString(),
+        expectedProposalId,
+        expectedThreadId,
+        tx: txResult
+      });
+    } catch (error) {
+      if (error instanceof TxError4) {
+        return c.error({
+          code: error.code,
+          message: error.message,
+          retryable: error.code === "NONCE_CONFLICT"
+        });
+      }
+      throw error;
+    }
+  }
+});
 
 // src/error-handling.ts
 import { AsyncLocalStorage } from "async_hooks";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spectratools/assembly-cli",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "CLI for Assembly governance on Abstract (members, council, forum, proposals, and treasury).",
   "type": "module",
   "license": "MIT",
@@ -33,7 +33,7 @@
     "ox": "^0.14.0",
     "viem": "^2.47.0",
     "@spectratools/cli-shared": "0.1.1",
-    "@spectratools/tx-shared": "0.4.3"
+    "@spectratools/tx-shared": "0.5.1"
   },
   "devDependencies": {
     "typescript": "5.7.3",