@spectratools/assembly-cli 0.8.2 → 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,6 +6012,7 @@ forum.command("stats", {
 });
 
 // src/commands/governance.ts
+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")
@@ -5635,6 +6026,14 @@ var proposalStatusLabels = {
   4: "defeated",
   5: "cancelled"
 };
+var PROPOSAL_STATUS_PENDING = 0;
+var PROPOSAL_STATUS_ACTIVE = 1;
+var PROPOSAL_STATUS_PASSED = 2;
+var supportChoiceToValue = {
+  against: 0,
+  for: 1,
+  abstain: 2
+};
 function proposalStatus(status) {
   const statusCode = asNum(status);
   return {
@@ -5749,6 +6148,23 @@ function serializeProposal(proposal) {
     description: proposal.description
   };
 }
+async function readProposalCount(client) {
+  return await client.readContract({
+    abi: governanceAbi,
+    address: ABSTRACT_MAINNET_ADDRESSES.governance,
+    functionName: "proposalCount"
+  });
+}
+async function readProposalById(client, proposalId) {
+  return decodeProposal(
+    await client.readContract({
+      abi: governanceAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.governance,
+      functionName: "proposals",
+      args: [BigInt(proposalId)]
+    })
+  );
+}
 var governance = Cli3.create("governance", {
   description: "Inspect Assembly governance proposals, votes, and parameters."
 });
@@ -5806,7 +6222,10 @@ governance.command("proposals", {
           description: "Inspect or vote:",
           commands: [
             { command: "governance proposal", args: { id: "<id>" } },
-            { command: "governance vote", args: { id: "<id>" } }
+            {
+              command: "governance vote",
+              args: { proposalId: "<id>", support: "<for|against|abstain>" }
+            }
           ]
         }
       }
@@ -5846,103 +6265,475 @@ governance.command("proposal", {
     return c.ok(serializeProposal(proposal));
   }
 });
-governance.command("has-voted", {
-  description: "Check if an address has voted on a proposal.",
+governance.command("has-voted", {
+  description: "Check if an address has voted on a proposal.",
+  args: z4.object({
+    proposalId: z4.coerce.number().int().positive().describe("Proposal id (1-indexed)"),
+    address: z4.string().describe("Voter address")
+  }),
+  env: env3,
+  output: z4.object({
+    proposalId: z4.number(),
+    address: z4.string(),
+    hasVoted: z4.boolean()
+  }),
+  examples: [
+    {
+      args: {
+        proposalId: 1,
+        address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
+      },
+      description: "Check whether an address already voted"
+    }
+  ],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const hasVoted = await client.readContract({
+      abi: governanceAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.governance,
+      functionName: "hasVoted",
+      args: [BigInt(c.args.proposalId), c.args.address]
+    });
+    return c.ok({
+      proposalId: c.args.proposalId,
+      address: toChecksum(c.args.address),
+      hasVoted
+    });
+  }
+});
+governance.command("params", {
+  description: "Read governance threshold and timing parameters.",
+  env: env3,
+  output: z4.object({
+    deliberationPeriod: z4.number(),
+    votePeriod: z4.number(),
+    quorumBps: z4.number(),
+    constitutionalDeliberationPeriod: z4.number(),
+    constitutionalVotePeriod: z4.number(),
+    constitutionalPassBps: z4.number(),
+    majorPassBps: z4.number(),
+    parameterPassBps: z4.number(),
+    significantPassBps: z4.number(),
+    significantThresholdBps: z4.number(),
+    routineThresholdBps: z4.number(),
+    timelockPeriod: z4.number()
+  }),
+  examples: [{ description: "Inspect governance timing and pass thresholds" }],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const getters = [
+      "deliberationPeriod",
+      "votePeriod",
+      "quorumBps",
+      "constitutionalDeliberationPeriod",
+      "constitutionalVotePeriod",
+      "constitutionalPassBps",
+      "majorPassBps",
+      "parameterPassBps",
+      "significantPassBps",
+      "significantThresholdBps",
+      "routineThresholdBps",
+      "timelockPeriod"
+    ];
+    const values = await client.multicall({
+      allowFailure: false,
+      contracts: getters.map((name) => ({
+        abi: governanceAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.governance,
+        functionName: name
+      }))
+    });
+    return c.ok({
+      deliberationPeriod: asNum(values[0]),
+      votePeriod: asNum(values[1]),
+      quorumBps: asNum(values[2]),
+      constitutionalDeliberationPeriod: asNum(values[3]),
+      constitutionalVotePeriod: asNum(values[4]),
+      constitutionalPassBps: asNum(values[5]),
+      majorPassBps: asNum(values[6]),
+      parameterPassBps: asNum(values[7]),
+      significantPassBps: asNum(values[8]),
+      significantThresholdBps: asNum(values[9]),
+      routineThresholdBps: asNum(values[10]),
+      timelockPeriod: asNum(values[11])
+    });
+  }
+});
+var txResultOutput3 = z4.union([
+  z4.object({
+    status: z4.enum(["success", "reverted"]),
+    hash: z4.string(),
+    blockNumber: z4.number(),
+    gasUsed: z4.string(),
+    from: z4.string(),
+    to: z4.string().nullable(),
+    effectiveGasPrice: z4.string().optional()
+  }),
+  z4.object({
+    status: z4.literal("dry-run"),
+    estimatedGas: z4.string(),
+    simulationResult: z4.unknown()
+  })
+]);
+governance.command("vote", {
+  description: "Cast a governance vote on a proposal.",
+  hint: "Requires PRIVATE_KEY environment variable for signing.",
+  args: z4.object({
+    proposalId: z4.coerce.number().int().positive().describe("Proposal id (1-indexed)"),
+    support: z4.enum(["for", "against", "abstain"]).describe("Vote support: for, against, or abstain")
+  }),
+  options: writeOptions,
+  env: writeEnv,
+  output: z4.object({
+    proposalId: z4.number(),
+    proposalTitle: z4.string(),
+    support: z4.enum(["for", "against", "abstain"]),
+    supportValue: z4.number(),
+    tx: txResultOutput3
+  }),
+  examples: [
+    {
+      args: { proposalId: 1, support: "for" },
+      description: "Vote in favor of proposal #1"
+    },
+    {
+      args: { proposalId: 1, support: "abstain" },
+      options: { "dry-run": true },
+      description: "Simulate casting an abstain vote"
+    }
+  ],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const account = resolveAccount(c.env);
+    const proposalCount = await readProposalCount(client);
+    if (c.args.proposalId > Number(proposalCount)) {
+      return c.error({
+        code: "OUT_OF_RANGE",
+        message: `Proposal id ${c.args.proposalId} does not exist (proposalCount: ${proposalCount})`,
+        retryable: false
+      });
+    }
+    const proposal = await readProposalById(client, c.args.proposalId);
+    const status = proposalStatus(proposal.status);
+    if (status.statusCode !== PROPOSAL_STATUS_ACTIVE) {
+      return c.error({
+        code: "PROPOSAL_NOT_VOTING",
+        message: `Proposal ${c.args.proposalId} is ${status.status} and cannot be voted right now.`,
+        retryable: false
+      });
+    }
+    const hasVoted = await client.readContract({
+      abi: governanceAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.governance,
+      functionName: "hasVoted",
+      args: [BigInt(c.args.proposalId), account.address]
+    });
+    if (hasVoted) {
+      return c.error({
+        code: "ALREADY_VOTED",
+        message: `Address ${toChecksum(account.address)} has already voted on proposal ${c.args.proposalId}.`,
+        retryable: false
+      });
+    }
+    const supportValue = supportChoiceToValue[c.args.support];
+    try {
+      const txResult = await assemblyWriteTx({
+        env: c.env,
+        options: c.options,
+        address: ABSTRACT_MAINNET_ADDRESSES.governance,
+        abi: governanceAbi,
+        functionName: "castVote",
+        args: [BigInt(c.args.proposalId), supportValue]
+      });
+      return c.ok({
+        proposalId: c.args.proposalId,
+        proposalTitle: proposal.title,
+        support: c.args.support,
+        supportValue,
+        tx: txResult
+      });
+    } catch (error) {
+      if (error instanceof TxError2) {
+        return c.error({
+          code: error.code,
+          message: error.message,
+          retryable: error.code === "NONCE_CONFLICT"
+        });
+      }
+      throw error;
+    }
+  }
+});
+governance.command("propose", {
+  description: "Create a new council-originated governance proposal.",
+  hint: "Requires PRIVATE_KEY environment variable for signing.",
+  options: writeOptions.extend({
+    title: z4.string().min(1).describe("Proposal title"),
+    description: z4.string().min(1).describe("Proposal description"),
+    kind: z4.coerce.number().int().nonnegative().max(255).describe("Proposal kind enum value"),
+    category: z4.string().default("governance").describe("Forum category label for the proposal"),
+    "risk-tier": z4.coerce.number().int().nonnegative().max(255).optional().describe("Optional max allowed intent risk tier (default: 0)"),
+    amount: z4.string().optional().describe("Optional treasury amount hint (currently unsupported for intent encoding)"),
+    recipient: z4.string().optional().describe("Optional treasury recipient hint (currently unsupported for intent encoding)")
+  }),
+  env: writeEnv,
+  output: z4.object({
+    proposer: z4.string(),
+    category: z4.string(),
+    kind: z4.number(),
+    title: z4.string(),
+    description: z4.string(),
+    expectedProposalId: z4.number(),
+    tx: txResultOutput3
+  }),
+  examples: [
+    {
+      options: {
+        title: "Increase quorum requirement",
+        description: "Raise quorum from 10% to 12% for governance votes.",
+        kind: 3
+      },
+      description: "Create a governance proposal from a council member account"
+    }
+  ],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const account = resolveAccount(c.env);
+    if (c.options.amount && !c.options.recipient || !c.options.amount && c.options.recipient) {
+      return c.error({
+        code: "INVALID_PROPOSAL_OPTIONS",
+        message: "Both --amount and --recipient must be provided together when setting transfer hints.",
+        retryable: false
+      });
+    }
+    if (c.options.amount || c.options.recipient) {
+      return c.error({
+        code: "UNSUPPORTED_TRANSFER_INTENT",
+        message: "Transfer intents are not yet supported by `governance propose`. Omit --amount/--recipient and use intent-specific tooling.",
+        retryable: false
+      });
+    }
+    const isCouncilMember = await client.readContract({
+      abi: councilSeatsAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.councilSeats,
+      functionName: "isCouncilMember",
+      args: [account.address]
+    });
+    if (!isCouncilMember) {
+      return c.error({
+        code: "NOT_COUNCIL_MEMBER",
+        message: `Address ${toChecksum(account.address)} is not an active council member and cannot create a council proposal.`,
+        retryable: false
+      });
+    }
+    const proposalCountBefore = await readProposalCount(client);
+    const expectedProposalId = Number(proposalCountBefore) + 1;
+    const proposalInput = {
+      kind: c.options.kind,
+      title: c.options.title,
+      description: c.options.description,
+      intentSteps: [],
+      intentConstraints: {
+        deadline: 0,
+        maxAllowedRiskTier: c.options["risk-tier"] ?? 0
+      },
+      configUpdates: []
+    };
+    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,
+        kind: c.options.kind,
+        title: c.options.title,
+        description: c.options.description,
+        expectedProposalId,
+        tx: txResult
+      });
+    } catch (error) {
+      if (error instanceof TxError2) {
+        return c.error({
+          code: error.code,
+          message: error.message,
+          retryable: error.code === "NONCE_CONFLICT"
+        });
+      }
+      throw error;
+    }
+  }
+});
+governance.command("queue", {
+  description: "Finalize voting and queue an eligible proposal into timelock.",
+  hint: "Requires PRIVATE_KEY environment variable for signing.",
   args: z4.object({
-    proposalId: z4.coerce.number().int().positive().describe("Proposal id (1-indexed)"),
-    address: z4.string().describe("Voter address")
+    proposalId: z4.coerce.number().int().positive().describe("Proposal id (1-indexed)")
   }),
-  env: env3,
+  options: writeOptions,
+  env: writeEnv,
   output: z4.object({
     proposalId: z4.number(),
-    address: z4.string(),
-    hasVoted: z4.boolean()
+    proposalTitle: z4.string(),
+    statusBefore: z4.string(),
+    tx: txResultOutput3
   }),
   examples: [
     {
-      args: {
-        proposalId: 1,
-        address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
-      },
-      description: "Check whether an address already voted"
+      args: { proposalId: 1 },
+      description: "Finalize voting for proposal #1 and queue if passed"
     }
   ],
   async run(c) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
-    const hasVoted = await client.readContract({
-      abi: governanceAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.governance,
-      functionName: "hasVoted",
-      args: [BigInt(c.args.proposalId), c.args.address]
-    });
-    return c.ok({
-      proposalId: c.args.proposalId,
-      address: toChecksum(c.args.address),
-      hasVoted
-    });
+    const proposalCount = await readProposalCount(client);
+    if (c.args.proposalId > Number(proposalCount)) {
+      return c.error({
+        code: "OUT_OF_RANGE",
+        message: `Proposal id ${c.args.proposalId} does not exist (proposalCount: ${proposalCount})`,
+        retryable: false
+      });
+    }
+    const proposal = await readProposalById(client, c.args.proposalId);
+    const status = proposalStatus(proposal.status);
+    if (status.statusCode === PROPOSAL_STATUS_PASSED) {
+      return c.error({
+        code: "ALREADY_QUEUED",
+        message: `Proposal ${c.args.proposalId} is already queued in timelock.`,
+        retryable: false
+      });
+    }
+    if (status.statusCode === PROPOSAL_STATUS_PENDING) {
+      return c.error({
+        code: "PROPOSAL_NOT_QUEUEABLE",
+        message: `Proposal ${c.args.proposalId} is still in deliberation and cannot be queued yet.`,
+        retryable: false
+      });
+    }
+    if (status.statusCode !== PROPOSAL_STATUS_ACTIVE) {
+      return c.error({
+        code: "PROPOSAL_NOT_QUEUEABLE",
+        message: `Proposal ${c.args.proposalId} is ${status.status} and cannot be queued.`,
+        retryable: false
+      });
+    }
+    const latestBlock = await client.getBlock({ blockTag: "latest" });
+    if (latestBlock.timestamp < proposal.voteEndAt) {
+      return c.error({
+        code: "VOTING_STILL_ACTIVE",
+        message: `Proposal ${c.args.proposalId} voting window is still open (ends ${relTime(proposal.voteEndAt)}).`,
+        retryable: false
+      });
+    }
+    try {
+      const txResult = await assemblyWriteTx({
+        env: c.env,
+        options: c.options,
+        address: ABSTRACT_MAINNET_ADDRESSES.governance,
+        abi: governanceAbi,
+        functionName: "finalizeVote",
+        args: [BigInt(c.args.proposalId)]
+      });
+      return c.ok({
+        proposalId: c.args.proposalId,
+        proposalTitle: proposal.title,
+        statusBefore: status.status,
+        tx: txResult
+      });
+    } catch (error) {
+      if (error instanceof TxError2) {
+        return c.error({
+          code: error.code,
+          message: error.message,
+          retryable: error.code === "NONCE_CONFLICT"
+        });
+      }
+      throw error;
+    }
   }
 });
-governance.command("params", {
-  description: "Read governance threshold and timing parameters.",
-  env: env3,
+governance.command("execute", {
+  description: "Execute a queued governance proposal after timelock expiry.",
+  hint: "Requires PRIVATE_KEY environment variable for signing.",
+  args: z4.object({
+    proposalId: z4.coerce.number().int().positive().describe("Proposal id (1-indexed)")
+  }),
+  options: writeOptions,
+  env: writeEnv,
   output: z4.object({
-    deliberationPeriod: z4.number(),
-    votePeriod: z4.number(),
-    quorumBps: z4.number(),
-    constitutionalDeliberationPeriod: z4.number(),
-    constitutionalVotePeriod: z4.number(),
-    constitutionalPassBps: z4.number(),
-    majorPassBps: z4.number(),
-    parameterPassBps: z4.number(),
-    significantPassBps: z4.number(),
-    significantThresholdBps: z4.number(),
-    routineThresholdBps: z4.number(),
-    timelockPeriod: z4.number()
+    proposalId: z4.number(),
+    proposalTitle: z4.string(),
+    timelockEndsAt: timestampOutput3,
+    tx: txResultOutput3
   }),
-  examples: [{ description: "Inspect governance timing and pass thresholds" }],
+  examples: [
+    {
+      args: { proposalId: 1 },
+      description: "Execute proposal #1 after timelock has expired"
+    }
+  ],
   async run(c) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
-    const getters = [
-      "deliberationPeriod",
-      "votePeriod",
-      "quorumBps",
-      "constitutionalDeliberationPeriod",
-      "constitutionalVotePeriod",
-      "constitutionalPassBps",
-      "majorPassBps",
-      "parameterPassBps",
-      "significantPassBps",
-      "significantThresholdBps",
-      "routineThresholdBps",
-      "timelockPeriod"
-    ];
-    const values = await client.multicall({
-      allowFailure: false,
-      contracts: getters.map((name) => ({
-        abi: governanceAbi,
+    const proposalCount = await readProposalCount(client);
+    if (c.args.proposalId > Number(proposalCount)) {
+      return c.error({
+        code: "OUT_OF_RANGE",
+        message: `Proposal id ${c.args.proposalId} does not exist (proposalCount: ${proposalCount})`,
+        retryable: false
+      });
+    }
+    const proposal = await readProposalById(client, c.args.proposalId);
+    const status = proposalStatus(proposal.status);
+    if (status.statusCode !== PROPOSAL_STATUS_PASSED) {
+      return c.error({
+        code: "PROPOSAL_NOT_EXECUTABLE",
+        message: `Proposal ${c.args.proposalId} is ${status.status} and cannot be executed.`,
+        retryable: false
+      });
+    }
+    const latestBlock = await client.getBlock({ blockTag: "latest" });
+    if (latestBlock.timestamp < proposal.timelockEndsAt) {
+      return c.error({
+        code: "TIMELOCK_ACTIVE",
+        message: `Proposal ${c.args.proposalId} timelock has not expired yet (ends ${relTime(proposal.timelockEndsAt)}).`,
+        retryable: false
+      });
+    }
+    try {
+      const txResult = await assemblyWriteTx({
+        env: c.env,
+        options: c.options,
         address: ABSTRACT_MAINNET_ADDRESSES.governance,
-        functionName: name
-      }))
-    });
-    return c.ok({
-      deliberationPeriod: asNum(values[0]),
-      votePeriod: asNum(values[1]),
-      quorumBps: asNum(values[2]),
-      constitutionalDeliberationPeriod: asNum(values[3]),
-      constitutionalVotePeriod: asNum(values[4]),
-      constitutionalPassBps: asNum(values[5]),
-      majorPassBps: asNum(values[6]),
-      parameterPassBps: asNum(values[7]),
-      significantPassBps: asNum(values[8]),
-      significantThresholdBps: asNum(values[9]),
-      routineThresholdBps: asNum(values[10]),
-      timelockPeriod: asNum(values[11])
-    });
+        abi: governanceAbi,
+        functionName: "executeProposal",
+        args: [BigInt(c.args.proposalId)]
+      });
+      return c.ok({
+        proposalId: c.args.proposalId,
+        proposalTitle: proposal.title,
+        timelockEndsAt: timeValue(proposal.timelockEndsAt, c.format),
+        tx: txResult
+      });
+    } catch (error) {
+      if (error instanceof TxError2) {
+        return c.error({
+          code: error.code,
+          message: error.message,
+          retryable: error.code === "NONCE_CONFLICT"
+        });
+      }
+      throw error;
+    }
   }
 });
 
 // src/commands/members.ts
-import { TxError } 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;
@@ -6435,7 +7226,7 @@ members.command("register", {
         } : void 0
       );
     } catch (error) {
-      if (error instanceof TxError && 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}`,
@@ -6486,7 +7277,7 @@ members.command("heartbeat", {
         } : void 0
       );
     } catch (error) {
-      if (error instanceof TxError && 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}`,
@@ -6537,7 +7328,7 @@ members.command("renew", {
         } : void 0
       );
     } catch (error) {
-      if (error instanceof TxError && 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}`,
@@ -6550,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."
 });
@@ -6677,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.8.2",
+  "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.2"
+    "@spectratools/tx-shared": "0.5.1"
   },
   "devDependencies": {
     "typescript": "5.7.3",