@spectratools/assembly-cli 0.13.0 → 0.14.0

package/dist/cli.js

@@ -9,7 +9,7 @@ import {
   shutdownTelemetry,
   withCommandSpan as withCommandSpan2
 } from "@spectratools/cli-shared/telemetry";
-import { Cli as Cli6, z as z9 } from "incur";
+import { Cli as Cli7, z as z10 } from "incur";
 
 // src/commands/_common.ts
 import { checksumAddress, weiToEth } from "@spectratools/cli-shared";
@@ -4358,8 +4358,8 @@ var writeOptions = z.object({
   "max-fee": z.string().optional().describe("Max fee per gas override in wei (EIP-1559)"),
   nonce: z.number().optional().describe("Nonce override")
 });
-function resolveAccount(env6) {
-  const signer = createPrivateKeySigner(env6.PRIVATE_KEY);
+function resolveAccount(env7) {
+  const signer = createPrivateKeySigner(env7.PRIVATE_KEY);
   return signer.account;
 }
 function formatTxResult(result) {
@@ -4381,10 +4381,10 @@ function formatTxResult(result) {
   };
 }
 async function assemblyWriteTx(opts) {
-  const { env: env6, options, address, abi, functionName, args, value } = opts;
-  const account = resolveAccount(env6);
-  const publicClient = createAssemblyPublicClient(env6.ABSTRACT_RPC_URL);
-  const walletClient = createAssemblyWalletClient(account, env6.ABSTRACT_RPC_URL);
+  const { env: env7, options, address, abi, functionName, args, value } = opts;
+  const account = resolveAccount(env7);
+  const publicClient = createAssemblyPublicClient(env7.ABSTRACT_RPC_URL);
+  const walletClient = createAssemblyWalletClient(account, env7.ABSTRACT_RPC_URL);
   const result = await executeTx({
     publicClient,
     walletClient,
@@ -4459,9 +4459,9 @@ council.command("seats", {
         args: [id]
       }))
     }) : [];
-    const seats = seatTuples.map(decodeSeat);
+    const seats2 = seatTuples.map(decodeSeat);
     return c.ok(
-      seats.map((seat, idx) => ({
+      seats2.map((seat, idx) => ({
         id: idx,
         owner: toChecksum(seat.owner),
         startAt: timeValue(seat.startAt, c.format),
@@ -4546,10 +4546,10 @@ council.command("members", {
         args: [id]
       }))
     }) : [];
-    const seats = seatTuples.map(decodeSeat);
+    const seats2 = seatTuples.map(decodeSeat);
     const activeOwners = [
       ...new Set(
-        seats.filter((x) => !x.forfeited && asNum(x.endAt) > Math.floor(Date.now() / 1e3)).map((x) => x.owner)
+        seats2.filter((x) => !x.forfeited && asNum(x.endAt) > Math.floor(Date.now() / 1e3)).map((x) => x.owner)
       )
     ];
     const powers = activeOwners.length ? await client.multicall({
@@ -5797,27 +5797,99 @@ var petitionDigestSchema = z4.object({
   threadId: z4.number(),
   hasSigned: z4.boolean().optional()
 });
+var proposalSummarySchema = z4.object({
+  id: z4.number(),
+  title: z4.string(),
+  status: z4.string(),
+  statusCode: z4.number(),
+  createdAt: z4.number(),
+  hasVoted: z4.boolean().optional()
+});
+var threadSummarySchema = z4.object({
+  id: z4.number(),
+  title: z4.string(),
+  category: z4.string(),
+  createdAt: z4.number()
+});
+var commentSummarySchema = z4.object({
+  id: z4.number(),
+  threadId: z4.number(),
+  author: z4.string(),
+  createdAt: z4.number()
+});
+var petitionSummarySchema = z4.object({
+  id: z4.number(),
+  title: z4.string(),
+  category: z4.string(),
+  signatures: z4.number(),
+  promoted: z4.boolean(),
+  createdAt: z4.number(),
+  hasSigned: z4.boolean().optional()
+});
+var filtersMetaSchema = z4.object({
+  since: z4.string().optional(),
+  until: z4.string().optional(),
+  omitComments: z4.boolean().optional(),
+  omitMembers: z4.boolean().optional(),
+  omitPetitions: z4.boolean().optional(),
+  proposalsLimit: z4.number().optional(),
+  threadsLimit: z4.number().optional(),
+  commentsLimit: z4.number().optional(),
+  petitionsLimit: z4.number().optional(),
+  summaryOnly: z4.boolean().optional(),
+  proposalStatus: z4.string().optional()
+});
 var digestOutputSchema = z4.object({
   meta: z4.object({
     chainId: z4.number(),
     fetchedAt: z4.string(),
-    address: z4.string().optional()
+    address: z4.string().optional(),
+    filters: filtersMetaSchema.optional()
   }),
-  proposals: z4.array(proposalDigestSchema),
-  threads: z4.array(threadDigestSchema),
-  comments: z4.array(commentDigestSchema),
-  petitions: z4.array(petitionDigestSchema),
+  proposals: z4.array(z4.union([proposalDigestSchema, proposalSummarySchema])),
+  threads: z4.array(z4.union([threadDigestSchema, threadSummarySchema])),
+  comments: z4.array(z4.union([commentDigestSchema, commentSummarySchema])).optional(),
+  petitions: z4.array(z4.union([petitionDigestSchema, petitionSummarySchema])).optional(),
   members: z4.object({
     count: z4.number(),
     items: z4.array(memberItemSchema)
-  }),
+  }).optional(),
   errors: z4.array(z4.string())
 });
+function parseDuration(value) {
+  const match = value.match(/^(\d+(?:\.\d+)?)\s*(m|h|d)$/i);
+  if (!match) return null;
+  const amount = Number.parseFloat(match[1]);
+  const unit = match[2].toLowerCase();
+  switch (unit) {
+    case "m":
+      return amount * 60 * 1e3;
+    case "h":
+      return amount * 3600 * 1e3;
+    case "d":
+      return amount * 86400 * 1e3;
+    default:
+      return null;
+  }
+}
+var validProposalStatuses = new Set(Object.values(proposalStatusLabels));
 function registerDigestCommand(cli2) {
   cli2.command("digest", {
     description: "Aggregate proposals, threads, comments, petitions, and members into a single governance snapshot.",
     options: z4.object({
-      address: z4.string().optional().describe("Wallet address to enrich proposals (hasVoted) and petitions (hasSigned)")
+      address: z4.string().optional().describe("Wallet address to enrich proposals (hasVoted) and petitions (hasSigned)"),
+      since: z4.string().optional().describe("Only items created/updated after this ISO-8601 timestamp"),
+      last: z4.string().optional().describe("Duration shorthand (e.g. 24h, 7d, 30m) \u2014 converted to --since"),
+      until: z4.string().optional().describe("Only items created/updated before this ISO-8601 timestamp"),
+      "omit-comments": z4.boolean().optional().describe("Exclude comments from output"),
+      "omit-members": z4.boolean().optional().describe("Exclude members from output"),
+      "omit-petitions": z4.boolean().optional().describe("Exclude petitions from output"),
+      "proposals-limit": z4.number().optional().describe("Return only the most recent N proposals"),
+      "threads-limit": z4.number().optional().describe("Return only the most recent N threads"),
+      "comments-limit": z4.number().optional().describe("Return only the most recent N comments"),
+      "petitions-limit": z4.number().optional().describe("Return only the most recent N petitions"),
+      "summary-only": z4.boolean().optional().describe("Return only counts/metadata per section (no full bodies)"),
+      "proposal-status": z4.string().optional().describe("Filter proposals by status (pending/active/passed/executed/defeated/cancelled)")
     }),
     env: digestEnv,
     output: digestOutputSchema,
@@ -5826,6 +5898,18 @@ function registerDigestCommand(cli2) {
       {
         options: { address: "0x230Ccc765765d729fFb1897D538f773b92005Aa2" },
         description: "Fetch digest with wallet-relative enrichment"
+      },
+      {
+        options: { last: "24h" },
+        description: "Fetch digest for the last 24 hours"
+      },
+      {
+        options: { "summary-only": true },
+        description: "Fetch digest with only summary metadata"
+      },
+      {
+        options: { "proposal-status": "active", "omit-comments": true },
+        description: "Fetch only active proposals, omitting comments"
       }
     ],
     async run(c) {
@@ -5833,12 +5917,69 @@ function registerDigestCommand(cli2) {
         const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
         const errors = [];
         const address = c.options.address ? toChecksum(c.options.address) : void 0;
+        let sinceTs;
+        let untilTs;
+        if (c.options.last && c.options.since) {
+          return c.error({
+            code: "INVALID_OPTIONS",
+            message: "Cannot specify both --since and --last",
+            retryable: false
+          });
+        }
+        if (c.options.last) {
+          const durationMs = parseDuration(c.options.last);
+          if (durationMs === null) {
+            return c.error({
+              code: "INVALID_DURATION",
+              message: `Invalid duration format: "${c.options.last}". Use e.g. 24h, 7d, 30m`,
+              retryable: false
+            });
+          }
+          sinceTs = Math.floor((Date.now() - durationMs) / 1e3);
+        } else if (c.options.since) {
+          const parsed = Date.parse(c.options.since);
+          if (Number.isNaN(parsed)) {
+            return c.error({
+              code: "INVALID_TIMESTAMP",
+              message: `Invalid --since timestamp: "${c.options.since}"`,
+              retryable: false
+            });
+          }
+          sinceTs = Math.floor(parsed / 1e3);
+        }
+        if (c.options.until) {
+          const parsed = Date.parse(c.options.until);
+          if (Number.isNaN(parsed)) {
+            return c.error({
+              code: "INVALID_TIMESTAMP",
+              message: `Invalid --until timestamp: "${c.options.until}"`,
+              retryable: false
+            });
+          }
+          untilTs = Math.floor(parsed / 1e3);
+        }
+        const proposalStatusFilter = c.options["proposal-status"];
+        if (proposalStatusFilter && !validProposalStatuses.has(proposalStatusFilter)) {
+          return c.error({
+            code: "INVALID_STATUS",
+            message: `Invalid --proposal-status: "${proposalStatusFilter}". Valid: ${[...validProposalStatuses].join(", ")}`,
+            retryable: false
+          });
+        }
+        const omitComments = c.options["omit-comments"] ?? false;
+        const omitMembers = c.options["omit-members"] ?? false;
+        const omitPetitions = c.options["omit-petitions"] ?? false;
+        const summaryOnly = c.options["summary-only"] ?? false;
+        const proposalsLimit = c.options["proposals-limit"];
+        const threadsLimit = c.options["threads-limit"];
+        const commentsLimit = c.options["comments-limit"];
+        const petitionsLimit = c.options["petitions-limit"];
         const [proposalsResult, threadsResult, commentsResult, petitionsResult, membersResult] = await Promise.allSettled([
           fetchAllProposals(client),
           fetchAllThreads(client),
-          fetchAllComments(client),
-          fetchAllPetitions(client),
-          fetchMemberList(client, c.env.ASSEMBLY_INDEXER_URL)
+          omitComments ? Promise.resolve([]) : fetchAllComments(client),
+          omitPetitions ? Promise.resolve([]) : fetchAllPetitions(client),
+          omitMembers ? Promise.resolve({ members: [], fallbackReason: void 0 }) : fetchMemberList(client, c.env.ASSEMBLY_INDEXER_URL)
         ]);
         let proposals = [];
         if (proposalsResult.status === "fulfilled") {
@@ -5853,42 +5994,86 @@ function registerDigestCommand(cli2) {
           errors.push(`threads: ${threadsResult.reason}`);
         }
         let comments = [];
-        if (commentsResult.status === "fulfilled") {
-          comments = commentsResult.value;
-        } else {
-          errors.push(`comments: ${commentsResult.reason}`);
+        if (!omitComments) {
+          if (commentsResult.status === "fulfilled") {
+            comments = commentsResult.value;
+          } else {
+            errors.push(`comments: ${commentsResult.reason}`);
+          }
         }
         let petitions = [];
-        if (petitionsResult.status === "fulfilled") {
-          petitions = petitionsResult.value;
-        } else {
-          errors.push(`petitions: ${petitionsResult.reason}`);
+        if (!omitPetitions) {
+          if (petitionsResult.status === "fulfilled") {
+            petitions = petitionsResult.value;
+          } else {
+            errors.push(`petitions: ${petitionsResult.reason}`);
+          }
         }
         let memberIdentities = [];
-        if (membersResult.status === "fulfilled") {
-          const loaded = membersResult.value;
-          memberIdentities = loaded.members;
-          if (loaded.fallbackReason) {
-            process.stderr.write(
-              `${JSON.stringify({
-                level: "warn",
-                code: loaded.fallbackReason.code,
-                message: "Member snapshot indexer is unavailable. Falling back to on-chain Registered events.",
-                url: loaded.fallbackReason.url
-              })}
+        if (!omitMembers) {
+          if (membersResult.status === "fulfilled") {
+            const loaded = membersResult.value;
+            memberIdentities = loaded.members;
+            if (loaded.fallbackReason) {
+              process.stderr.write(
+                `${JSON.stringify({
+                  level: "warn",
+                  code: loaded.fallbackReason.code,
+                  message: "Member snapshot indexer is unavailable. Falling back to on-chain Registered events.",
+                  url: loaded.fallbackReason.url
+                })}
 `
-            );
-          }
-        } else {
-          const err = membersResult.reason;
-          if (err instanceof AssemblyApiValidationError) {
-            errors.push(`members: ${err.details.code}`);
+              );
+            }
           } else {
-            errors.push(`members: ${err}`);
+            const err = membersResult.reason;
+            if (err instanceof AssemblyApiValidationError) {
+              errors.push(`members: ${err.details.code}`);
+            } else {
+              errors.push(`members: ${err}`);
+            }
           }
         }
+        if (sinceTs !== void 0) {
+          proposals = proposals.filter((p) => Number(p.createdAt) >= sinceTs);
+          threads = threads.filter((t) => t.createdAt >= sinceTs);
+          comments = comments.filter((cm) => cm.createdAt >= sinceTs);
+          petitions = petitions.filter((p) => p.createdAt >= sinceTs);
+        }
+        if (untilTs !== void 0) {
+          proposals = proposals.filter((p) => Number(p.createdAt) <= untilTs);
+          threads = threads.filter((t) => t.createdAt <= untilTs);
+          comments = comments.filter((cm) => cm.createdAt <= untilTs);
+          petitions = petitions.filter((p) => p.createdAt <= untilTs);
+        }
+        if (proposalStatusFilter) {
+          const statusLabelToCode = /* @__PURE__ */ new Map();
+          for (const [code, label] of Object.entries(proposalStatusLabels)) {
+            statusLabelToCode.set(label, Number(code));
+          }
+          const targetCode = statusLabelToCode.get(proposalStatusFilter);
+          if (targetCode !== void 0) {
+            proposals = proposals.filter((p) => Number(p.status) === targetCode);
+          }
+        }
+        proposals.sort((a, b) => Number(b.createdAt) - Number(a.createdAt));
+        threads.sort((a, b) => b.createdAt - a.createdAt);
+        comments.sort((a, b) => b.createdAt - a.createdAt);
+        petitions.sort((a, b) => b.createdAt - a.createdAt);
+        if (proposalsLimit !== void 0) {
+          proposals = proposals.slice(0, proposalsLimit);
+        }
+        if (threadsLimit !== void 0) {
+          threads = threads.slice(0, threadsLimit);
+        }
+        if (commentsLimit !== void 0) {
+          comments = comments.slice(0, commentsLimit);
+        }
+        if (petitionsLimit !== void 0) {
+          petitions = petitions.slice(0, petitionsLimit);
+        }
         let memberItems = [];
-        if (memberIdentities.length > 0) {
+        if (!omitMembers && memberIdentities.length > 0) {
           try {
             const onchainStates = await fetchMemberOnchainState(
               client,
@@ -5908,17 +6093,11 @@ function registerDigestCommand(cli2) {
         let hasVotedMap = /* @__PURE__ */ new Map();
         let hasSignedMap = /* @__PURE__ */ new Map();
         if (address) {
+          const proposalIds = proposals.map((_, i) => i + 1);
+          const petitionIds = petitions.map((p) => p.id);
           const [votedResult, signedResult] = await Promise.allSettled([
-            fetchHasVotedBatch(
-              client,
-              address,
-              proposals.map((_, i) => i + 1)
-            ),
-            fetchHasSignedBatch(
-              client,
-              address,
-              petitions.map((p) => p.id)
-            )
+            fetchHasVotedBatch(client, address, proposalIds),
+            omitPetitions ? Promise.resolve(/* @__PURE__ */ new Map()) : fetchHasSignedBatch(client, address, petitionIds)
           ]);
           if (votedResult.status === "fulfilled") {
             hasVotedMap = votedResult.value;
@@ -5931,66 +6110,137 @@ function registerDigestCommand(cli2) {
             errors.push(`hasSigned enrichment: ${signedResult.reason}`);
           }
         }
-        const serializedProposals = proposals.map((p, i) => {
-          const serialized = serializeProposal(p);
-          const entry = {
-            id: i + 1,
-            ...serialized
-          };
-          if (address) {
-            entry.hasVoted = hasVotedMap.get(i + 1) ?? false;
+        let serializedProposals;
+        if (summaryOnly) {
+          serializedProposals = proposals.map((p, i) => {
+            const { status, statusCode } = serializeProposal(p);
+            const entry = {
+              id: i + 1,
+              title: p.title,
+              status,
+              statusCode,
+              createdAt: Number(p.createdAt)
+            };
+            if (address) {
+              entry.hasVoted = hasVotedMap.get(i + 1) ?? false;
+            }
+            return entry;
+          });
+        } else {
+          serializedProposals = proposals.map((p, i) => {
+            const serialized = serializeProposal(p);
+            const entry = {
+              id: i + 1,
+              ...serialized
+            };
+            if (address) {
+              entry.hasVoted = hasVotedMap.get(i + 1) ?? false;
+            }
+            return entry;
+          });
+        }
+        let serializedThreads;
+        if (summaryOnly) {
+          serializedThreads = threads.map((t) => ({
+            id: t.id,
+            title: t.title,
+            category: t.category,
+            createdAt: t.createdAt
+          }));
+        } else {
+          serializedThreads = threads.map((t) => ({
+            id: t.id,
+            kind: t.kind,
+            author: t.author,
+            createdAt: t.createdAt,
+            category: t.category,
+            title: t.title,
+            proposalId: t.proposalId,
+            petitionId: t.petitionId
+          }));
+        }
+        let serializedComments;
+        if (!omitComments) {
+          if (summaryOnly) {
+            serializedComments = comments.map((cm) => ({
+              id: cm.id,
+              threadId: cm.threadId,
+              author: cm.author,
+              createdAt: cm.createdAt
+            }));
+          } else {
+            serializedComments = comments.map((cm) => ({
+              id: cm.id,
+              threadId: cm.threadId,
+              parentId: cm.parentId,
+              author: cm.author,
+              createdAt: cm.createdAt,
+              body: cm.body
+            }));
           }
-          return entry;
-        });
-        const serializedThreads = threads.map((t) => ({
-          id: t.id,
-          kind: t.kind,
-          author: t.author,
-          createdAt: t.createdAt,
-          category: t.category,
-          title: t.title,
-          proposalId: t.proposalId,
-          petitionId: t.petitionId
-        }));
-        const serializedComments = comments.map((cm) => ({
-          id: cm.id,
-          threadId: cm.threadId,
-          parentId: cm.parentId,
-          author: cm.author,
-          createdAt: cm.createdAt,
-          body: cm.body
-        }));
-        const serializedPetitions = petitions.map((p) => {
-          const entry = {
-            id: p.id,
-            proposer: p.proposer,
-            createdAt: p.createdAt,
-            category: p.category,
-            title: p.title,
-            body: p.body,
-            signatures: p.signatures,
-            promoted: p.promoted,
-            threadId: p.threadId
-          };
-          if (address) {
-            entry.hasSigned = hasSignedMap.get(p.id) ?? false;
+        }
+        let serializedPetitions;
+        if (!omitPetitions) {
+          if (summaryOnly) {
+            serializedPetitions = petitions.map((p) => {
+              const entry = {
+                id: p.id,
+                title: p.title,
+                category: p.category,
+                signatures: p.signatures,
+                promoted: p.promoted,
+                createdAt: p.createdAt
+              };
+              if (address) {
+                entry.hasSigned = hasSignedMap.get(p.id) ?? false;
+              }
+              return entry;
+            });
+          } else {
+            serializedPetitions = petitions.map((p) => {
+              const entry = {
+                id: p.id,
+                proposer: p.proposer,
+                createdAt: p.createdAt,
+                category: p.category,
+                title: p.title,
+                body: p.body,
+                signatures: p.signatures,
+                promoted: p.promoted,
+                threadId: p.threadId
+              };
+              if (address) {
+                entry.hasSigned = hasSignedMap.get(p.id) ?? false;
+              }
+              return entry;
+            });
           }
-          return entry;
-        });
+        }
+        const filtersMeta = {};
+        if (sinceTs !== void 0) filtersMeta.since = isoTime(sinceTs);
+        if (untilTs !== void 0) filtersMeta.until = isoTime(untilTs);
+        if (omitComments) filtersMeta.omitComments = true;
+        if (omitMembers) filtersMeta.omitMembers = true;
+        if (omitPetitions) filtersMeta.omitPetitions = true;
+        if (proposalsLimit !== void 0) filtersMeta.proposalsLimit = proposalsLimit;
+        if (threadsLimit !== void 0) filtersMeta.threadsLimit = threadsLimit;
+        if (commentsLimit !== void 0) filtersMeta.commentsLimit = commentsLimit;
+        if (petitionsLimit !== void 0) filtersMeta.petitionsLimit = petitionsLimit;
+        if (summaryOnly) filtersMeta.summaryOnly = true;
+        if (proposalStatusFilter) filtersMeta.proposalStatus = proposalStatusFilter;
+        const hasFilters = Object.keys(filtersMeta).length > 0;
         const output = {
           meta: {
             chainId: 2741,
             fetchedAt: (/* @__PURE__ */ new Date()).toISOString().replace(".000Z", "Z"),
-            ...address ? { address } : {}
+            ...address ? { address } : {},
+            ...hasFilters ? { filters: filtersMeta } : {}
           },
           proposals: serializedProposals,
           threads: serializedThreads,
-          comments: serializedComments,
-          petitions: serializedPetitions,
-          members: {
-            count: memberItems.length,
-            items: memberItems
-          },
+          ...omitComments ? {} : { comments: serializedComments },
+          ...omitPetitions ? {} : { petitions: serializedPetitions },
+          ...omitMembers ? {} : { members: { count: memberItems.length, items: memberItems } },
           errors
         };
         return c.ok(output);
@@ -7779,49 +8029,109 @@ members.command("renew", {
   }
 });
 
-// src/commands/treasury.ts
-import { TxError as TxError4 } from "@spectratools/tx-shared";
+// src/commands/seats.ts
 import { Cli as Cli5, z as z8 } from "incur";
-import { encodeAbiParameters, parseUnits, zeroAddress } from "viem";
 var env5 = z8.object({
   ABSTRACT_RPC_URL: z8.string().optional().describe("Abstract RPC URL override")
 });
 var timestampOutput5 = z8.union([z8.number(), z8.string()]);
-var txResultOutput4 = z8.union([
-  z8.object({
-    status: z8.literal("success"),
-    hash: z8.string(),
-    blockNumber: z8.number(),
-    gasUsed: z8.string(),
-    from: z8.string(),
-    to: z8.string().nullable(),
-    effectiveGasPrice: z8.string().optional()
+function decodeSeat2(value) {
+  const [owner, startAt, endAt, forfeited] = value;
+  return { owner, startAt, endAt, forfeited };
+}
+var seats = Cli5.create("seats", {
+  description: "Council seat aliases (compatibility shim for council seats)."
+});
+seats.command("list", {
+  description: "List all council seats and their occupancy windows (alias for council seats).",
+  env: env5,
+  output: z8.array(
+    z8.object({
+      id: z8.number(),
+      owner: z8.string(),
+      startAt: timestampOutput5,
+      startAtRelative: z8.string(),
+      endAt: timestampOutput5,
+      endAtRelative: z8.string(),
+      forfeited: z8.boolean()
+    })
+  ),
+  examples: [{ description: "List all council seats" }],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const count = await client.readContract({
+      abi: councilSeatsAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.councilSeats,
+      functionName: "seatCount"
+    });
+    const ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i));
+    const seatTuples = ids.length ? await client.multicall({
+      allowFailure: false,
+      contracts: ids.map((id) => ({
+        abi: councilSeatsAbi,
+        address: ABSTRACT_MAINNET_ADDRESSES.councilSeats,
+        functionName: "seats",
+        args: [id]
+      }))
+    }) : [];
+    const seatList = seatTuples.map(decodeSeat2);
+    return c.ok(
+      seatList.map((seat, idx) => ({
+        id: idx,
+        owner: toChecksum(seat.owner),
+        startAt: timeValue(seat.startAt, c.format),
+        startAtRelative: relTime(seat.startAt),
+        endAt: timeValue(seat.endAt, c.format),
+        endAtRelative: relTime(seat.endAt),
+        forfeited: seat.forfeited
+      }))
+    );
+  }
+});
+
+// src/commands/treasury.ts
+import { TxError as TxError4 } from "@spectratools/tx-shared";
+import { Cli as Cli6, z as z9 } from "incur";
+import { encodeAbiParameters, parseUnits, zeroAddress } from "viem";
+var env6 = z9.object({
+  ABSTRACT_RPC_URL: z9.string().optional().describe("Abstract RPC URL override")
+});
+var timestampOutput6 = z9.union([z9.number(), z9.string()]);
+var txResultOutput4 = z9.union([
+  z9.object({
+    status: z9.literal("success"),
+    hash: z9.string(),
+    blockNumber: z9.number(),
+    gasUsed: z9.string(),
+    from: z9.string(),
+    to: z9.string().nullable(),
+    effectiveGasPrice: z9.string().optional()
   }),
-  z8.object({
-    status: z8.literal("reverted"),
-    hash: z8.string(),
-    blockNumber: z8.number(),
-    gasUsed: z8.string(),
-    from: z8.string(),
-    to: z8.string().nullable(),
-    effectiveGasPrice: z8.string().optional()
+  z9.object({
+    status: z9.literal("reverted"),
+    hash: z9.string(),
+    blockNumber: z9.number(),
+    gasUsed: z9.string(),
+    from: z9.string(),
+    to: z9.string().nullable(),
+    effectiveGasPrice: z9.string().optional()
   }),
-  z8.object({
-    status: z8.literal("dry-run"),
-    estimatedGas: z8.string(),
-    simulationResult: z8.unknown()
+  z9.object({
+    status: z9.literal("dry-run"),
+    estimatedGas: z9.string(),
+    simulationResult: z9.unknown()
   })
 ]);
-var treasury = Cli5.create("treasury", {
+var treasury = Cli6.create("treasury", {
   description: "Inspect treasury balances, execution status, and spend controls."
 });
 treasury.command("balance", {
   description: "Get current native token balance for the treasury contract.",
-  env: env5,
-  output: z8.object({
-    address: z8.string(),
-    balanceWei: z8.string(),
-    balance: z8.string()
+  env: env6,
+  output: z9.object({
+    address: z9.string(),
+    balanceWei: z9.string(),
+    balance: z9.string()
   }),
   examples: [{ description: "Check treasury balance" }],
   async run(c) {
@@ -7836,13 +8146,13 @@ treasury.command("balance", {
 });
 treasury.command("whitelist", {
   description: "Check whether an asset address is treasury-whitelisted.",
-  args: z8.object({
-    asset: z8.string().describe("Token/asset contract address")
+  args: z9.object({
+    asset: z9.string().describe("Token/asset contract address")
   }),
-  env: env5,
-  output: z8.object({
-    asset: z8.string(),
-    whitelisted: z8.boolean()
+  env: env6,
+  output: z9.object({
+    asset: z9.string(),
+    whitelisted: z9.boolean()
   }),
   examples: [
     {
@@ -7863,12 +8173,12 @@ treasury.command("whitelist", {
 });
 treasury.command("major-spend-status", {
   description: "Read major-spend cooldown status for the treasury contract.",
-  env: env5,
-  output: z8.object({
-    majorSpendCooldownSeconds: z8.number(),
-    lastMajorSpendAt: timestampOutput5,
-    lastMajorSpendRelative: z8.string(),
-    isMajorSpendAllowed: z8.boolean()
+  env: env6,
+  output: z9.object({
+    majorSpendCooldownSeconds: z9.number(),
+    lastMajorSpendAt: timestampOutput6,
+    lastMajorSpendRelative: z9.string(),
+    isMajorSpendAllowed: z9.boolean()
   }),
   examples: [{ description: "Inspect treasury major-spend guardrails" }],
   async run(c) {
@@ -7902,13 +8212,13 @@ treasury.command("major-spend-status", {
 });
 treasury.command("executed", {
   description: "Check whether a treasury action for a proposal has executed.",
-  args: z8.object({
-    proposalId: z8.coerce.number().int().positive().describe("Governance proposal id")
+  args: z9.object({
+    proposalId: z9.coerce.number().int().positive().describe("Governance proposal id")
   }),
-  env: env5,
-  output: z8.object({
-    proposalId: z8.number(),
-    executed: z8.boolean()
+  env: env6,
+  output: z9.object({
+    proposalId: z9.number(),
+    executed: z9.boolean()
   }),
   examples: [{ args: { proposalId: 1 }, description: "Check execution status for proposal #1" }],
   async run(c) {
@@ -7938,25 +8248,25 @@ 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: z8.string().describe("Token address to spend (use 0x0000000000000000000000000000000000000000 for ETH)"),
-    recipient: z8.string().describe("Recipient address"),
-    amount: z8.string().describe("Token amount as decimal string (human units)"),
-    decimals: z8.coerce.number().int().min(0).max(36).default(18).describe("Token decimals used to parse --amount (default: 18)"),
-    title: z8.string().min(1).describe("Proposal title"),
-    description: z8.string().min(1).describe("Proposal description"),
-    category: z8.string().default("treasury").describe("Forum category label for this proposal"),
-    "risk-tier": z8.coerce.number().int().min(0).max(3).default(3).describe("Max allowed risk tier in intent constraints (0-3, default: 3)")
+    token: z9.string().describe("Token address to spend (use 0x0000000000000000000000000000000000000000 for ETH)"),
+    recipient: z9.string().describe("Recipient address"),
+    amount: z9.string().describe("Token amount as decimal string (human units)"),
+    decimals: z9.coerce.number().int().min(0).max(36).default(18).describe("Token decimals used to parse --amount (default: 18)"),
+    title: z9.string().min(1).describe("Proposal title"),
+    description: z9.string().min(1).describe("Proposal description"),
+    category: z9.string().default("treasury").describe("Forum category label for this proposal"),
+    "risk-tier": z9.coerce.number().int().min(0).max(3).default(3).describe("Max allowed risk tier in intent constraints (0-3, default: 3)")
   }),
   env: writeEnv,
-  output: z8.object({
-    proposer: z8.string(),
-    category: z8.string(),
-    token: z8.string(),
-    recipient: z8.string(),
-    amount: z8.string(),
-    amountWei: z8.string(),
-    expectedProposalId: z8.number(),
-    expectedThreadId: z8.number(),
+  output: z9.object({
+    proposer: z9.string(),
+    category: z9.string(),
+    token: z9.string(),
+    recipient: z9.string(),
+    amount: z9.string(),
+    amountWei: z9.string(),
+    expectedProposalId: z9.number(),
+    expectedThreadId: z9.number(),
     tx: txResultOutput4
   }),
   examples: [
@@ -8251,30 +8561,31 @@ function applyFriendlyErrorHandling(cli2) {
 // src/cli.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(readFileSync(resolve(__dirname, "../package.json"), "utf8"));
-var cli = Cli6.create("assembly", {
+var cli = Cli7.create("assembly", {
   version: pkg.version,
   description: "Assembly governance CLI for Abstract chain."
 });
 cli.command(members);
 cli.command(council);
+cli.command(seats);
 cli.command(forum);
 cli.command(governance);
 cli.command(treasury);
 registerDigestCommand(cli);
-var rootEnv = z9.object({
-  ABSTRACT_RPC_URL: z9.string().optional().describe("Abstract RPC URL override")
+var rootEnv = z10.object({
+  ABSTRACT_RPC_URL: z10.string().optional().describe("Abstract RPC URL override")
 });
-var timestampOutput6 = z9.union([z9.number(), z9.string()]);
+var timestampOutput7 = z10.union([z10.number(), z10.string()]);
 cli.command("status", {
   description: "Get a cross-contract Assembly snapshot (members, council, governance, treasury).",
   env: rootEnv,
-  output: z9.object({
-    activeMemberCount: z9.number(),
-    seatCount: z9.number(),
-    proposalCount: z9.number(),
-    currentAuctionDay: z9.number(),
-    currentAuctionSlot: z9.number(),
-    treasuryBalance: z9.string()
+  output: z10.object({
+    activeMemberCount: z10.number(),
+    seatCount: z10.number(),
+    proposalCount: z10.number(),
+    currentAuctionDay: z10.number(),
+    currentAuctionSlot: z10.number(),
+    treasuryBalance: z10.string()
   }),
   examples: [{ description: "Fetch the current Assembly system status" }],
   async run(c) {
@@ -8328,18 +8639,18 @@ cli.command("status", {
 });
 cli.command("health", {
   description: "Check cross-contract health for one address (membership, council, refunds, power).",
-  args: z9.object({
-    address: z9.string().describe("Member or wallet address to inspect")
+  args: z10.object({
+    address: z10.string().describe("Member or wallet address to inspect")
   }),
   env: rootEnv,
-  output: z9.object({
-    address: z9.string(),
-    isActive: z9.boolean(),
-    activeUntil: timestampOutput6,
-    activeUntilRelative: z9.string(),
-    isCouncilMember: z9.boolean(),
-    pendingReturnsWei: z9.string(),
-    votingPower: z9.number()
+  output: z10.object({
+    address: z10.string(),
+    isActive: z10.boolean(),
+    activeUntil: timestampOutput7,
+    activeUntilRelative: z10.string(),
+    isCouncilMember: z10.boolean(),
+    pendingReturnsWei: z10.string(),
+    votingPower: z10.number()
   }),
   examples: [
     {