@spectratools/assembly-cli 0.12.0 → 0.14.0

package/dist/cli.js

@@ -7,9 +7,9 @@ import { fileURLToPath } from "url";
 import {
   initTelemetry,
   shutdownTelemetry,
-  withCommandSpan
+  withCommandSpan as withCommandSpan2
 } from "@spectratools/cli-shared/telemetry";
-import { Cli as Cli6, z as z8 } 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({
@@ -5246,9 +5246,9 @@ council.command("withdraw-refund", {
   }
 });
 
-// src/commands/forum.ts
-import { TxError } from "@spectratools/tx-shared";
-import { Cli as Cli2, z as z3 } from "incur";
+// src/commands/digest.ts
+import { withCommandSpan } from "@spectratools/cli-shared/telemetry";
+import { z as z4 } from "incur";
 
 // src/services/forum.ts
 function decodeThread(value) {
@@ -5376,51 +5376,912 @@ async function fetchForumStats(client) {
       address: ABSTRACT_MAINNET_ADDRESSES.forum,
       functionName: "petitionCount"
     }),
-    client.readContract({
-      abi: forumAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.forum,
-      functionName: "petitionThresholdBps"
-    })
-  ]);
-  return {
-    threadCount: asNum(threadCount),
-    commentCount: asNum(commentCount),
-    petitionCount: asNum(petitionCount),
-    petitionThresholdBps: asNum(petitionThresholdBps)
-  };
+    client.readContract({
+      abi: forumAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.forum,
+      functionName: "petitionThresholdBps"
+    })
+  ]);
+  return {
+    threadCount: asNum(threadCount),
+    commentCount: asNum(commentCount),
+    petitionCount: asNum(petitionCount),
+    petitionThresholdBps: asNum(petitionThresholdBps)
+  };
+}
+async function fetchHasSignedBatch(client, address, petitionIds) {
+  if (petitionIds.length === 0) return /* @__PURE__ */ new Map();
+  const results = await client.multicall({
+    allowFailure: false,
+    contracts: petitionIds.map((id) => ({
+      abi: forumAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.forum,
+      functionName: "hasSignedPetition",
+      args: [BigInt(id), address]
+    }))
+  });
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < petitionIds.length; i++) {
+    map.set(petitionIds[i], results[i]);
+  }
+  return map;
+}
+
+// src/services/governance.ts
+var proposalStatusLabels = {
+  0: "pending",
+  1: "active",
+  2: "passed",
+  3: "executed",
+  4: "defeated",
+  5: "cancelled"
+};
+function proposalStatus(status) {
+  const statusCode = asNum(status);
+  return {
+    status: proposalStatusLabels[statusCode] ?? `unknown-${statusCode}`,
+    statusCode
+  };
+}
+function decodeProposal(value) {
+  const [
+    kind,
+    configRiskTier,
+    origin,
+    status,
+    proposer,
+    threadId,
+    petitionId,
+    createdAt,
+    deliberationEndsAt,
+    voteStartAt,
+    voteEndAt,
+    timelockEndsAt,
+    activeSeatsSnapshot,
+    forVotes,
+    againstVotes,
+    abstainVotes,
+    amount,
+    snapshotAssetBalance,
+    transferIntent,
+    intentDeadline,
+    intentMaxRiskTier,
+    title,
+    description
+  ] = value;
+  return {
+    kind,
+    configRiskTier,
+    origin,
+    status,
+    proposer: toChecksum(proposer),
+    threadId,
+    petitionId,
+    createdAt,
+    deliberationEndsAt,
+    voteStartAt,
+    voteEndAt,
+    timelockEndsAt,
+    activeSeatsSnapshot,
+    forVotes,
+    againstVotes,
+    abstainVotes,
+    amount,
+    snapshotAssetBalance,
+    transferIntent,
+    intentDeadline,
+    intentMaxRiskTier,
+    title,
+    description
+  };
+}
+function serializeProposal(proposal) {
+  const status = proposalStatus(proposal.status);
+  return {
+    kind: asNum(proposal.kind),
+    configRiskTier: asNum(proposal.configRiskTier),
+    origin: asNum(proposal.origin),
+    status: status.status,
+    statusCode: status.statusCode,
+    proposer: proposal.proposer,
+    threadId: asNum(proposal.threadId),
+    petitionId: asNum(proposal.petitionId),
+    createdAt: asNum(proposal.createdAt),
+    deliberationEndsAt: asNum(proposal.deliberationEndsAt),
+    voteStartAt: asNum(proposal.voteStartAt),
+    voteEndAt: asNum(proposal.voteEndAt),
+    timelockEndsAt: asNum(proposal.timelockEndsAt),
+    activeSeatsSnapshot: asNum(proposal.activeSeatsSnapshot),
+    forVotes: proposal.forVotes.toString(),
+    againstVotes: proposal.againstVotes.toString(),
+    abstainVotes: proposal.abstainVotes.toString(),
+    amount: proposal.amount.toString(),
+    snapshotAssetBalance: proposal.snapshotAssetBalance.toString(),
+    transferIntent: proposal.transferIntent,
+    intentDeadline: asNum(proposal.intentDeadline),
+    intentMaxRiskTier: asNum(proposal.intentMaxRiskTier),
+    title: proposal.title,
+    description: proposal.description
+  };
+}
+async function fetchProposalCount(client) {
+  return await client.readContract({
+    abi: governanceAbi,
+    address: ABSTRACT_MAINNET_ADDRESSES.governance,
+    functionName: "proposalCount"
+  });
+}
+async function fetchProposalById(client, id) {
+  return decodeProposal(
+    await client.readContract({
+      abi: governanceAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.governance,
+      functionName: "proposals",
+      args: [BigInt(id)]
+    })
+  );
+}
+async function fetchAllProposals(client) {
+  const count = await fetchProposalCount(client);
+  const ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i + 1));
+  if (ids.length === 0) return [];
+  const proposalTuples = await client.multicall({
+    allowFailure: false,
+    contracts: ids.map((id) => ({
+      abi: governanceAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.governance,
+      functionName: "proposals",
+      args: [id]
+    }))
+  });
+  return proposalTuples.map(decodeProposal);
+}
+async function fetchHasVotedBatch(client, address, proposalIds) {
+  if (proposalIds.length === 0) return /* @__PURE__ */ new Map();
+  const results = await client.multicall({
+    allowFailure: false,
+    contracts: proposalIds.map((id) => ({
+      abi: governanceAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.governance,
+      functionName: "hasVoted",
+      args: [BigInt(id), address]
+    }))
+  });
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < proposalIds.length; i++) {
+    map.set(proposalIds[i], results[i]);
+  }
+  return map;
+}
+
+// src/services/members.ts
+import { z as z3 } from "incur";
+var DEFAULT_MEMBER_SNAPSHOT_URL = "https://www.theaiassembly.org/api/indexer/members";
+var REGISTERED_EVENT_SCAN_STEP = 100000n;
+var REGISTERED_EVENT_SCAN_TIMEOUT_MS = 2e4;
+var memberSnapshotEntrySchema = z3.union([
+  z3.string(),
+  z3.object({
+    address: z3.string(),
+    ens: z3.string().optional(),
+    name: z3.string().optional()
+  })
+]);
+var memberSnapshotSchema = z3.array(memberSnapshotEntrySchema);
+var AssemblyApiValidationError = class extends Error {
+  constructor(details) {
+    super("Assembly API response validation failed");
+    this.details = details;
+    this.name = "AssemblyApiValidationError";
+  }
+};
+var AssemblyIndexerUnavailableError = class extends Error {
+  constructor(details) {
+    super("Assembly indexer unavailable");
+    this.details = details;
+    this.name = "AssemblyIndexerUnavailableError";
+  }
+};
+function memberSnapshotEntryToIdentity(entry) {
+  if (typeof entry === "string") return { address: entry };
+  const identity = { address: entry.address };
+  if (entry.ens !== void 0) identity.ens = entry.ens;
+  if (entry.name !== void 0) identity.name = entry.name;
+  return identity;
+}
+function mergeMemberIdentities(entries) {
+  const byAddress = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = entry.address.toLowerCase();
+    const existing = byAddress.get(key);
+    if (!existing) {
+      byAddress.set(key, entry);
+      continue;
+    }
+    const merged = { address: existing.address };
+    const ens = existing.ens ?? entry.ens;
+    const name = existing.name ?? entry.name;
+    if (ens !== void 0) merged.ens = ens;
+    if (name !== void 0) merged.name = name;
+    byAddress.set(key, merged);
+  }
+  return [...byAddress.values()];
+}
+async function memberSnapshot(url) {
+  let res;
+  try {
+    res = await fetch(url);
+  } catch (error) {
+    throw new AssemblyIndexerUnavailableError({
+      code: "ASSEMBLY_INDEXER_UNAVAILABLE",
+      url,
+      reason: error instanceof Error ? error.message : String(error)
+    });
+  }
+  if (!res.ok) {
+    throw new AssemblyIndexerUnavailableError({
+      code: "ASSEMBLY_INDEXER_UNAVAILABLE",
+      url,
+      status: res.status,
+      statusText: res.statusText
+    });
+  }
+  const json = await res.json();
+  const parsed = memberSnapshotSchema.safeParse(json);
+  if (parsed.success) {
+    return mergeMemberIdentities(parsed.data.map(memberSnapshotEntryToIdentity));
+  }
+  throw new AssemblyApiValidationError({
+    code: "INVALID_ASSEMBLY_API_RESPONSE",
+    url,
+    issues: parsed.error.issues,
+    response: json
+  });
+}
+async function withTimeout(promise, timeoutMs, timeoutMessage) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          reject(new Error(timeoutMessage));
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function membersFromRegisteredEvents(client) {
+  const latestBlock = await client.getBlockNumber();
+  const addresses = /* @__PURE__ */ new Set();
+  for (let fromBlock = ABSTRACT_MAINNET_DEPLOYMENT_BLOCKS.registry; fromBlock <= latestBlock; fromBlock += REGISTERED_EVENT_SCAN_STEP) {
+    const toBlock = fromBlock + REGISTERED_EVENT_SCAN_STEP - 1n > latestBlock ? latestBlock : fromBlock + REGISTERED_EVENT_SCAN_STEP - 1n;
+    const events = await client.getContractEvents({
+      abi: registryAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.registry,
+      eventName: "Registered",
+      fromBlock,
+      toBlock,
+      strict: true
+    });
+    for (const event of events) {
+      const member = event.args.member;
+      if (typeof member === "string") {
+        addresses.add(member);
+      }
+    }
+  }
+  return [...addresses].map((address) => ({ address }));
+}
+async function fetchMemberList(client, snapshotUrl) {
+  const url = snapshotUrl ?? DEFAULT_MEMBER_SNAPSHOT_URL;
+  try {
+    return { members: await memberSnapshot(url) };
+  } catch (error) {
+    if (error instanceof AssemblyApiValidationError) {
+      throw error;
+    }
+    if (!(error instanceof AssemblyIndexerUnavailableError)) {
+      throw error;
+    }
+    const fallbackMembers = await withTimeout(
+      membersFromRegisteredEvents(client),
+      REGISTERED_EVENT_SCAN_TIMEOUT_MS,
+      `Registered event fallback scan timed out after ${REGISTERED_EVENT_SCAN_TIMEOUT_MS}ms`
+    );
+    return {
+      members: mergeMemberIdentities(fallbackMembers),
+      fallbackReason: error.details
+    };
+  }
+}
+async function fetchMemberOnchainState(client, addresses) {
+  if (addresses.length === 0) return [];
+  const calls = addresses.flatMap((address) => [
+    {
+      abi: registryAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.registry,
+      functionName: "isActive",
+      args: [address]
+    },
+    {
+      abi: registryAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.registry,
+      functionName: "members",
+      args: [address]
+    }
+  ]);
+  const values = await client.multicall({ allowFailure: false, contracts: calls });
+  return addresses.map((address, i) => {
+    const active = values[i * 2];
+    const info = values[i * 2 + 1];
+    return {
+      address: toChecksum(address),
+      active,
+      registered: info.registered,
+      activeUntil: info.activeUntil,
+      lastHeartbeatAt: info.lastHeartbeatAt
+    };
+  });
+}
+
+// src/commands/digest.ts
+var digestEnv = z4.object({
+  ABSTRACT_RPC_URL: z4.string().optional().describe("Abstract RPC URL override"),
+  ASSEMBLY_INDEXER_URL: z4.string().optional().describe("Optional members snapshot endpoint (default: theaiassembly.org indexer)")
+});
+var memberItemSchema = z4.object({
+  address: z4.string(),
+  active: z4.boolean(),
+  registered: z4.boolean(),
+  activeUntil: z4.string(),
+  lastHeartbeatAt: z4.string()
+});
+var proposalDigestSchema = z4.object({
+  id: z4.number(),
+  kind: z4.number(),
+  configRiskTier: z4.number(),
+  origin: z4.number(),
+  status: z4.string(),
+  statusCode: z4.number(),
+  proposer: z4.string(),
+  threadId: z4.number(),
+  petitionId: z4.number(),
+  createdAt: z4.number(),
+  deliberationEndsAt: z4.number(),
+  voteStartAt: z4.number(),
+  voteEndAt: z4.number(),
+  timelockEndsAt: z4.number(),
+  activeSeatsSnapshot: z4.number(),
+  forVotes: z4.string(),
+  againstVotes: z4.string(),
+  abstainVotes: z4.string(),
+  amount: z4.string(),
+  snapshotAssetBalance: z4.string(),
+  transferIntent: z4.boolean(),
+  intentDeadline: z4.number(),
+  intentMaxRiskTier: z4.number(),
+  title: z4.string(),
+  description: z4.string(),
+  hasVoted: z4.boolean().optional()
+});
+var threadDigestSchema = z4.object({
+  id: z4.number(),
+  kind: z4.number(),
+  author: z4.string(),
+  createdAt: z4.number(),
+  category: z4.string(),
+  title: z4.string(),
+  proposalId: z4.number(),
+  petitionId: z4.number()
+});
+var commentDigestSchema = z4.object({
+  id: z4.number(),
+  threadId: z4.number(),
+  parentId: z4.number(),
+  author: z4.string(),
+  createdAt: z4.number(),
+  body: z4.string()
+});
+var petitionDigestSchema = z4.object({
+  id: z4.number(),
+  proposer: z4.string(),
+  createdAt: z4.number(),
+  category: z4.string(),
+  title: z4.string(),
+  body: z4.string(),
+  signatures: z4.number(),
+  promoted: z4.boolean(),
+  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(),
+    filters: filtersMetaSchema.optional()
+  }),
+  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)"),
+      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,
+    examples: [
+      { description: "Fetch a full governance digest" },
+      {
+        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) {
+      return withCommandSpan("assembly digest", { address: c.options.address }, async () => {
+        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),
+          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") {
+          proposals = proposalsResult.value;
+        } else {
+          errors.push(`proposals: ${proposalsResult.reason}`);
+        }
+        let threads = [];
+        if (threadsResult.status === "fulfilled") {
+          threads = threadsResult.value;
+        } else {
+          errors.push(`threads: ${threadsResult.reason}`);
+        }
+        let comments = [];
+        if (!omitComments) {
+          if (commentsResult.status === "fulfilled") {
+            comments = commentsResult.value;
+          } else {
+            errors.push(`comments: ${commentsResult.reason}`);
+          }
+        }
+        let petitions = [];
+        if (!omitPetitions) {
+          if (petitionsResult.status === "fulfilled") {
+            petitions = petitionsResult.value;
+          } else {
+            errors.push(`petitions: ${petitionsResult.reason}`);
+          }
+        }
+        let memberIdentities = [];
+        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}`);
+            }
+          }
+        }
+        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 (!omitMembers && memberIdentities.length > 0) {
+          try {
+            const onchainStates = await fetchMemberOnchainState(
+              client,
+              memberIdentities.map((m) => m.address)
+            );
+            memberItems = onchainStates.map((s) => ({
+              address: s.address,
+              active: s.active,
+              registered: s.registered,
+              activeUntil: isoTime(s.activeUntil),
+              lastHeartbeatAt: isoTime(s.lastHeartbeatAt)
+            }));
+          } catch (err) {
+            errors.push(`members onchain state: ${err}`);
+          }
+        }
+        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, proposalIds),
+            omitPetitions ? Promise.resolve(/* @__PURE__ */ new Map()) : fetchHasSignedBatch(client, address, petitionIds)
+          ]);
+          if (votedResult.status === "fulfilled") {
+            hasVotedMap = votedResult.value;
+          } else {
+            errors.push(`hasVoted enrichment: ${votedResult.reason}`);
+          }
+          if (signedResult.status === "fulfilled") {
+            hasSignedMap = signedResult.value;
+          } else {
+            errors.push(`hasSigned enrichment: ${signedResult.reason}`);
+          }
+        }
+        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
+            }));
+          }
+        }
+        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;
+            });
+          }
+        }
+        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 } : {},
+            ...hasFilters ? { filters: filtersMeta } : {}
+          },
+          proposals: serializedProposals,
+          threads: serializedThreads,
+          ...omitComments ? {} : { comments: serializedComments },
+          ...omitPetitions ? {} : { petitions: serializedPetitions },
+          ...omitMembers ? {} : { members: { count: memberItems.length, items: memberItems } },
+          errors
+        };
+        return c.ok(output);
+      });
+    }
+  });
 }
 
 // src/commands/forum.ts
-var env2 = z3.object({
-  ABSTRACT_RPC_URL: z3.string().optional().describe("Abstract RPC URL override")
+import { TxError } from "@spectratools/tx-shared";
+import { Cli as Cli2, z as z5 } from "incur";
+var env2 = z5.object({
+  ABSTRACT_RPC_URL: z5.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)")
+  PRIVATE_KEY: z5.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()
+var timestampOutput2 = z5.union([z5.number(), z5.string()]);
+var txResultOutput2 = z5.union([
+  z5.object({
+    status: z5.literal("success"),
+    hash: z5.string(),
+    blockNumber: z5.number(),
+    gasUsed: z5.string(),
+    from: z5.string(),
+    to: z5.string().nullable(),
+    effectiveGasPrice: z5.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()
+  z5.object({
+    status: z5.literal("reverted"),
+    hash: z5.string(),
+    blockNumber: z5.number(),
+    gasUsed: z5.string(),
+    from: z5.string(),
+    to: z5.string().nullable(),
+    effectiveGasPrice: z5.string().optional()
   }),
-  z3.object({
-    status: z3.literal("dry-run"),
-    estimatedGas: z3.string(),
-    simulationResult: z3.unknown()
+  z5.object({
+    status: z5.literal("dry-run"),
+    estimatedGas: z5.string(),
+    simulationResult: z5.unknown()
   })
 ]);
 var forum = Cli2.create("forum", {
@@ -5429,19 +6290,19 @@ var forum = Cli2.create("forum", {
 forum.command("threads", {
   description: "List forum threads with author and creation metadata.",
   env: env2,
-  output: z3.object({
-    threads: z3.array(
-      z3.object({
-        id: z3.number(),
-        kind: z3.number(),
-        author: z3.string(),
+  output: z5.object({
+    threads: z5.array(
+      z5.object({
+        id: z5.number(),
+        kind: z5.number(),
+        author: z5.string(),
         createdAt: timestampOutput2,
-        createdAtRelative: z3.string(),
-        category: z3.string().nullable().optional(),
-        title: z3.string().nullable().optional()
+        createdAtRelative: z5.string(),
+        category: z5.string().nullable().optional(),
+        title: z5.string().nullable().optional()
       })
     ),
-    count: z3.number()
+    count: z5.number()
   }),
   examples: [{ description: "List all forum threads" }],
   async run(c) {
@@ -5475,13 +6336,13 @@ forum.command("threads", {
 });
 forum.command("thread", {
   description: "Get one thread and all comments associated with it.",
-  args: z3.object({
-    id: z3.coerce.number().int().positive().describe("Thread id (1-indexed)")
+  args: z5.object({
+    id: z5.coerce.number().int().positive().describe("Thread id (1-indexed)")
   }),
   env: env2,
-  output: z3.object({
-    thread: z3.record(z3.string(), z3.unknown()),
-    comments: z3.array(z3.record(z3.string(), z3.unknown()))
+  output: z5.object({
+    thread: z5.record(z5.string(), z5.unknown()),
+    comments: z5.array(z5.record(z5.string(), z5.unknown()))
   }),
   examples: [{ args: { id: 1 }, description: "Fetch thread #1 and its comments" }],
   async run(c) {
@@ -5514,11 +6375,11 @@ forum.command("thread", {
 });
 forum.command("comments", {
   description: "List comments for a thread id.",
-  args: z3.object({
-    threadId: z3.coerce.number().int().positive().describe("Thread id to filter comments by")
+  args: z5.object({
+    threadId: z5.coerce.number().int().positive().describe("Thread id to filter comments by")
   }),
   env: env2,
-  output: z3.array(z3.record(z3.string(), z3.unknown())),
+  output: z5.array(z5.record(z5.string(), z5.unknown())),
   examples: [{ args: { threadId: 1 }, description: "List comments for thread #1" }],
   async run(c) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
@@ -5530,15 +6391,15 @@ forum.command("comments", {
 });
 forum.command("comment", {
   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 (read) or thread id (write)")
+  args: z5.object({
+    id: z5.coerce.number().int().positive().describe("Comment id (read) or thread id (write)")
   }),
   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)")
+    body: z5.string().min(1).optional().describe("Comment body (write mode)"),
+    "parent-id": z5.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()),
+  output: z5.record(z5.string(), z5.unknown()),
   examples: [
     { args: { id: 1 }, description: "Fetch comment #1" },
     {
@@ -5653,16 +6514,16 @@ 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")
+    category: z5.string().min(1).describe("Thread category label (e.g., general, governance)"),
+    title: z5.string().min(1).describe("Thread title"),
+    body: z5.string().min(1).describe("Thread body")
   }),
   env: writeEnv,
-  output: z3.object({
-    author: z3.string(),
-    category: z3.string(),
-    title: z3.string(),
-    expectedThreadId: z3.number(),
+  output: z5.object({
+    author: z5.string(),
+    category: z5.string(),
+    title: z5.string(),
+    expectedThreadId: z5.number(),
     tx: txResultOutput2
   }),
   examples: [
@@ -5730,19 +6591,19 @@ forum.command("post", {
 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")
+  args: z5.object({
+    threadId: z5.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")
+    body: z5.string().min(1).describe("Comment body"),
+    "parent-id": z5.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(),
+  output: z5.object({
+    author: z5.string(),
+    threadId: z5.number(),
+    parentId: z5.number(),
+    expectedCommentId: z5.number(),
     tx: txResultOutput2
   }),
   examples: [
@@ -5829,20 +6690,20 @@ forum.command("create-petition", {
   description: "Create a new petition for community-initiated proposals.",
   hint: "Requires PRIVATE_KEY environment variable for signing.",
   options: writeOptions.extend({
-    title: z3.string().min(1).describe("Petition title"),
-    description: z3.string().min(1).describe("Petition description"),
-    kind: z3.coerce.number().int().nonnegative().max(255).describe("Proposal kind enum value"),
-    category: z3.string().default("governance").describe("Forum category label for the petition")
+    title: z5.string().min(1).describe("Petition title"),
+    description: z5.string().min(1).describe("Petition description"),
+    kind: z5.coerce.number().int().nonnegative().max(255).describe("Proposal kind enum value"),
+    category: z5.string().default("governance").describe("Forum category label for the petition")
   }),
   env: writeEnv,
-  output: z3.object({
-    proposer: z3.string(),
-    category: z3.string(),
-    kind: z3.number(),
-    title: z3.string(),
-    description: z3.string(),
-    expectedPetitionId: z3.number(),
-    expectedThreadId: z3.number(),
+  output: z5.object({
+    proposer: z5.string(),
+    category: z5.string(),
+    kind: z5.number(),
+    title: z5.string(),
+    description: z5.string(),
+    expectedPetitionId: z5.number(),
+    expectedThreadId: z5.number(),
     tx: txResultOutput2
   }),
   examples: [
@@ -5945,15 +6806,15 @@ forum.command("create-petition", {
 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)")
+  args: z5.object({
+    petitionId: z5.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(),
+  output: z5.object({
+    signer: z5.string(),
+    petitionId: z5.number(),
+    expectedSignatures: z5.number(),
     tx: txResultOutput2
   }),
   examples: [{ args: { petitionId: 1 }, description: "Sign petition #1" }],
@@ -6040,7 +6901,7 @@ forum.command("sign-petition", {
 forum.command("petitions", {
   description: "List petitions submitted in the forum contract.",
   env: env2,
-  output: z3.array(z3.record(z3.string(), z3.unknown())),
+  output: z5.array(z5.record(z5.string(), z5.unknown())),
   examples: [{ description: "List all petitions" }],
   async run(c) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
@@ -6050,11 +6911,11 @@ forum.command("petitions", {
 });
 forum.command("petition", {
   description: "Get one petition plus whether proposer already signed it.",
-  args: z3.object({
-    id: z3.coerce.number().int().positive().describe("Petition id (1-indexed)")
+  args: z5.object({
+    id: z5.coerce.number().int().positive().describe("Petition id (1-indexed)")
   }),
   env: env2,
-  output: z3.object({ proposerSigned: z3.boolean() }).passthrough(),
+  output: z5.object({ proposerSigned: z5.boolean() }).passthrough(),
   examples: [{ args: { id: 1 }, description: "Fetch petition #1" }],
   async run(c) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
@@ -6089,15 +6950,15 @@ forum.command("petition", {
 });
 forum.command("has-signed", {
   description: "Check whether an address signed a petition.",
-  args: z3.object({
-    petitionId: z3.coerce.number().int().positive().describe("Petition id (1-indexed)"),
-    address: z3.string().describe("Signer address to check")
+  args: z5.object({
+    petitionId: z5.coerce.number().int().positive().describe("Petition id (1-indexed)"),
+    address: z5.string().describe("Signer address to check")
   }),
   env: env2,
-  output: z3.object({
-    petitionId: z3.number(),
-    address: z3.string(),
-    hasSigned: z3.boolean()
+  output: z5.object({
+    petitionId: z5.number(),
+    address: z5.string(),
+    hasSigned: z5.boolean()
   }),
   examples: [
     {
@@ -6122,11 +6983,11 @@ forum.command("has-signed", {
 forum.command("stats", {
   description: "Read top-level forum counters and petition threshold.",
   env: env2,
-  output: z3.object({
-    threadCount: z3.number(),
-    commentCount: z3.number(),
-    petitionCount: z3.number(),
-    petitionThresholdBps: z3.number()
+  output: z5.object({
+    threadCount: z5.number(),
+    commentCount: z5.number(),
+    petitionCount: z5.number(),
+    petitionThresholdBps: z5.number()
   }),
   examples: [{ description: "Get forum counts and petition threshold" }],
   async run(c) {
@@ -6137,176 +6998,44 @@ forum.command("stats", {
 
 // src/commands/governance.ts
 import { TxError as TxError2 } from "@spectratools/tx-shared";
-import { Cli as Cli3, z as z4 } from "incur";
-
-// src/services/governance.ts
-var proposalStatusLabels = {
-  0: "pending",
-  1: "active",
-  2: "passed",
-  3: "executed",
-  4: "defeated",
-  5: "cancelled"
-};
-function proposalStatus(status) {
-  const statusCode = asNum(status);
-  return {
-    status: proposalStatusLabels[statusCode] ?? `unknown-${statusCode}`,
-    statusCode
-  };
-}
-function decodeProposal(value) {
-  const [
-    kind,
-    configRiskTier,
-    origin,
-    status,
-    proposer,
-    threadId,
-    petitionId,
-    createdAt,
-    deliberationEndsAt,
-    voteStartAt,
-    voteEndAt,
-    timelockEndsAt,
-    activeSeatsSnapshot,
-    forVotes,
-    againstVotes,
-    abstainVotes,
-    amount,
-    snapshotAssetBalance,
-    transferIntent,
-    intentDeadline,
-    intentMaxRiskTier,
-    title,
-    description
-  ] = value;
-  return {
-    kind,
-    configRiskTier,
-    origin,
-    status,
-    proposer: toChecksum(proposer),
-    threadId,
-    petitionId,
-    createdAt,
-    deliberationEndsAt,
-    voteStartAt,
-    voteEndAt,
-    timelockEndsAt,
-    activeSeatsSnapshot,
-    forVotes,
-    againstVotes,
-    abstainVotes,
-    amount,
-    snapshotAssetBalance,
-    transferIntent,
-    intentDeadline,
-    intentMaxRiskTier,
-    title,
-    description
-  };
-}
-function serializeProposal(proposal) {
-  const status = proposalStatus(proposal.status);
-  return {
-    kind: asNum(proposal.kind),
-    configRiskTier: asNum(proposal.configRiskTier),
-    origin: asNum(proposal.origin),
-    status: status.status,
-    statusCode: status.statusCode,
-    proposer: proposal.proposer,
-    threadId: asNum(proposal.threadId),
-    petitionId: asNum(proposal.petitionId),
-    createdAt: asNum(proposal.createdAt),
-    deliberationEndsAt: asNum(proposal.deliberationEndsAt),
-    voteStartAt: asNum(proposal.voteStartAt),
-    voteEndAt: asNum(proposal.voteEndAt),
-    timelockEndsAt: asNum(proposal.timelockEndsAt),
-    activeSeatsSnapshot: asNum(proposal.activeSeatsSnapshot),
-    forVotes: proposal.forVotes.toString(),
-    againstVotes: proposal.againstVotes.toString(),
-    abstainVotes: proposal.abstainVotes.toString(),
-    amount: proposal.amount.toString(),
-    snapshotAssetBalance: proposal.snapshotAssetBalance.toString(),
-    transferIntent: proposal.transferIntent,
-    intentDeadline: asNum(proposal.intentDeadline),
-    intentMaxRiskTier: asNum(proposal.intentMaxRiskTier),
-    title: proposal.title,
-    description: proposal.description
-  };
-}
-async function fetchProposalCount(client) {
-  return await client.readContract({
-    abi: governanceAbi,
-    address: ABSTRACT_MAINNET_ADDRESSES.governance,
-    functionName: "proposalCount"
-  });
-}
-async function fetchProposalById(client, id) {
-  return decodeProposal(
-    await client.readContract({
-      abi: governanceAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.governance,
-      functionName: "proposals",
-      args: [BigInt(id)]
-    })
-  );
-}
-async function fetchAllProposals(client) {
-  const count = await fetchProposalCount(client);
-  const ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i + 1));
-  if (ids.length === 0) return [];
-  const proposalTuples = await client.multicall({
-    allowFailure: false,
-    contracts: ids.map((id) => ({
-      abi: governanceAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.governance,
-      functionName: "proposals",
-      args: [id]
-    }))
-  });
-  return proposalTuples.map(decodeProposal);
-}
-
-// src/commands/governance.ts
-var env3 = z4.object({
-  ABSTRACT_RPC_URL: z4.string().optional().describe("Abstract RPC URL override")
+import { Cli as Cli3, z as z6 } from "incur";
+var env3 = z6.object({
+  ABSTRACT_RPC_URL: z6.string().optional().describe("Abstract RPC URL override")
 });
-var timestampOutput3 = z4.union([z4.number(), z4.string()]);
+var timestampOutput3 = z6.union([z6.number(), z6.string()]);
 var PROPOSAL_STATUS_PENDING = 0;
-var PROPOSAL_STATUS_ACTIVE = 1;
-var PROPOSAL_STATUS_PASSED = 2;
-var supportChoiceToValue = {
-  against: 0,
-  for: 1,
-  abstain: 2
-};
-var proposalOutputSchema = z4.object({
-  kind: z4.number(),
-  configRiskTier: z4.number(),
-  origin: z4.number(),
-  status: z4.string(),
-  statusCode: z4.number(),
-  proposer: z4.string(),
-  threadId: z4.number(),
-  petitionId: z4.number(),
-  createdAt: z4.number(),
-  deliberationEndsAt: z4.number(),
-  voteStartAt: z4.number(),
-  voteEndAt: z4.number(),
-  timelockEndsAt: z4.number(),
-  activeSeatsSnapshot: z4.number(),
-  forVotes: z4.string(),
-  againstVotes: z4.string(),
-  abstainVotes: z4.string(),
-  amount: z4.string(),
-  snapshotAssetBalance: z4.string(),
-  transferIntent: z4.boolean(),
-  intentDeadline: z4.number(),
-  intentMaxRiskTier: z4.number(),
-  title: z4.string(),
-  description: z4.string()
+var PROPOSAL_STATUS_ACTIVE = 1;
+var PROPOSAL_STATUS_PASSED = 2;
+var supportChoiceToValue = {
+  against: 0,
+  for: 1,
+  abstain: 2
+};
+var proposalOutputSchema = z6.object({
+  kind: z6.number(),
+  configRiskTier: z6.number(),
+  origin: z6.number(),
+  status: z6.string(),
+  statusCode: z6.number(),
+  proposer: z6.string(),
+  threadId: z6.number(),
+  petitionId: z6.number(),
+  createdAt: z6.number(),
+  deliberationEndsAt: z6.number(),
+  voteStartAt: z6.number(),
+  voteEndAt: z6.number(),
+  timelockEndsAt: z6.number(),
+  activeSeatsSnapshot: z6.number(),
+  forVotes: z6.string(),
+  againstVotes: z6.string(),
+  abstainVotes: z6.string(),
+  amount: z6.string(),
+  snapshotAssetBalance: z6.string(),
+  transferIntent: z6.boolean(),
+  intentDeadline: z6.number(),
+  intentMaxRiskTier: z6.number(),
+  title: z6.string(),
+  description: z6.string()
 });
 var governance = Cli3.create("governance", {
   description: "Inspect Assembly governance proposals, votes, and parameters."
@@ -6314,19 +7043,19 @@ var governance = Cli3.create("governance", {
 governance.command("proposals", {
   description: "List governance proposals with status and vote end time.",
   env: env3,
-  output: z4.object({
-    proposals: z4.array(
-      z4.object({
-        id: z4.number(),
-        kind: z4.number(),
-        status: z4.string(),
-        statusCode: z4.number(),
-        title: z4.string().nullable().optional(),
+  output: z6.object({
+    proposals: z6.array(
+      z6.object({
+        id: z6.number(),
+        kind: z6.number(),
+        status: z6.string(),
+        statusCode: z6.number(),
+        title: z6.string().nullable().optional(),
         voteEndAt: timestampOutput3,
-        voteEndRelative: z4.string()
+        voteEndRelative: z6.string()
       })
     ),
-    count: z4.number()
+    count: z6.number()
   }),
   examples: [{ description: "List all proposals" }],
   async run(c) {
@@ -6362,8 +7091,8 @@ governance.command("proposals", {
 });
 governance.command("proposal", {
   description: "Get full raw proposal details by proposal id.",
-  args: z4.object({
-    id: z4.coerce.number().int().positive().describe("Proposal id (1-indexed)")
+  args: z6.object({
+    id: z6.coerce.number().int().positive().describe("Proposal id (1-indexed)")
   }),
   env: env3,
   output: proposalOutputSchema,
@@ -6384,15 +7113,15 @@ governance.command("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")
+  args: z6.object({
+    proposalId: z6.coerce.number().int().positive().describe("Proposal id (1-indexed)"),
+    address: z6.string().describe("Voter address")
   }),
   env: env3,
-  output: z4.object({
-    proposalId: z4.number(),
-    address: z4.string(),
-    hasVoted: z4.boolean()
+  output: z6.object({
+    proposalId: z6.number(),
+    address: z6.string(),
+    hasVoted: z6.boolean()
   }),
   examples: [
     {
@@ -6421,19 +7150,19 @@ governance.command("has-voted", {
 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()
+  output: z6.object({
+    deliberationPeriod: z6.number(),
+    votePeriod: z6.number(),
+    quorumBps: z6.number(),
+    constitutionalDeliberationPeriod: z6.number(),
+    constitutionalVotePeriod: z6.number(),
+    constitutionalPassBps: z6.number(),
+    majorPassBps: z6.number(),
+    parameterPassBps: z6.number(),
+    significantPassBps: z6.number(),
+    significantThresholdBps: z6.number(),
+    routineThresholdBps: z6.number(),
+    timelockPeriod: z6.number()
   }),
   examples: [{ description: "Inspect governance timing and pass thresholds" }],
   async run(c) {
@@ -6476,36 +7205,36 @@ governance.command("params", {
     });
   }
 });
-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()
+var txResultOutput3 = z6.union([
+  z6.object({
+    status: z6.enum(["success", "reverted"]),
+    hash: z6.string(),
+    blockNumber: z6.number(),
+    gasUsed: z6.string(),
+    from: z6.string(),
+    to: z6.string().nullable(),
+    effectiveGasPrice: z6.string().optional()
   }),
-  z4.object({
-    status: z4.literal("dry-run"),
-    estimatedGas: z4.string(),
-    simulationResult: z4.unknown()
+  z6.object({
+    status: z6.literal("dry-run"),
+    estimatedGas: z6.string(),
+    simulationResult: z6.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")
+  args: z6.object({
+    proposalId: z6.coerce.number().int().positive().describe("Proposal id (1-indexed)"),
+    support: z6.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(),
+  output: z6.object({
+    proposalId: z6.number(),
+    proposalTitle: z6.string(),
+    support: z6.enum(["for", "against", "abstain"]),
+    supportValue: z6.number(),
     tx: txResultOutput3
   }),
   examples: [
@@ -6585,22 +7314,22 @@ 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)")
+    title: z6.string().min(1).describe("Proposal title"),
+    description: z6.string().min(1).describe("Proposal description"),
+    kind: z6.coerce.number().int().nonnegative().max(255).describe("Proposal kind enum value"),
+    category: z6.string().default("governance").describe("Forum category label for the proposal"),
+    "risk-tier": z6.coerce.number().int().nonnegative().max(255).optional().describe("Optional max allowed intent risk tier (default: 0)"),
+    amount: z6.string().optional().describe("Optional treasury amount hint (currently unsupported for intent encoding)"),
+    recipient: z6.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(),
+  output: z6.object({
+    proposer: z6.string(),
+    category: z6.string(),
+    kind: z6.number(),
+    title: z6.string(),
+    description: z6.string(),
+    expectedProposalId: z6.number(),
     tx: txResultOutput3
   }),
   examples: [
@@ -6689,15 +7418,15 @@ governance.command("propose", {
 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)")
+  args: z6.object({
+    proposalId: z6.coerce.number().int().positive().describe("Proposal id (1-indexed)")
   }),
   options: writeOptions,
   env: writeEnv,
-  output: z4.object({
-    proposalId: z4.number(),
-    proposalTitle: z4.string(),
-    statusBefore: z4.string(),
+  output: z6.object({
+    proposalId: z6.number(),
+    proposalTitle: z6.string(),
+    statusBefore: z6.string(),
     tx: txResultOutput3
   }),
   examples: [
@@ -6732,308 +7461,133 @@ governance.command("queue", {
         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("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({
-    proposalId: z4.number(),
-    proposalTitle: z4.string(),
-    timelockEndsAt: timestampOutput3,
-    tx: txResultOutput3
-  }),
-  examples: [
-    {
-      args: { proposalId: 1 },
-      description: "Execute proposal #1 after timelock has expired"
-    }
-  ],
-  async run(c) {
-    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
-    const proposalCount = await fetchProposalCount(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 fetchProposalById(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,
-        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 as TxError3 } from "@spectratools/tx-shared";
-import { Cli as Cli4, z as z6 } from "incur";
-
-// src/services/members.ts
-import { z as z5 } from "incur";
-var DEFAULT_MEMBER_SNAPSHOT_URL = "https://www.theaiassembly.org/api/indexer/members";
-var REGISTERED_EVENT_SCAN_STEP = 100000n;
-var REGISTERED_EVENT_SCAN_TIMEOUT_MS = 2e4;
-var memberSnapshotEntrySchema = z5.union([
-  z5.string(),
-  z5.object({
-    address: z5.string(),
-    ens: z5.string().optional(),
-    name: z5.string().optional()
-  })
-]);
-var memberSnapshotSchema = z5.array(memberSnapshotEntrySchema);
-var AssemblyApiValidationError = class extends Error {
-  constructor(details) {
-    super("Assembly API response validation failed");
-    this.details = details;
-    this.name = "AssemblyApiValidationError";
-  }
-};
-var AssemblyIndexerUnavailableError = class extends Error {
-  constructor(details) {
-    super("Assembly indexer unavailable");
-    this.details = details;
-    this.name = "AssemblyIndexerUnavailableError";
-  }
-};
-function memberSnapshotEntryToIdentity(entry) {
-  if (typeof entry === "string") return { address: entry };
-  const identity = { address: entry.address };
-  if (entry.ens !== void 0) identity.ens = entry.ens;
-  if (entry.name !== void 0) identity.name = entry.name;
-  return identity;
-}
-function mergeMemberIdentities(entries) {
-  const byAddress = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const key = entry.address.toLowerCase();
-    const existing = byAddress.get(key);
-    if (!existing) {
-      byAddress.set(key, entry);
-      continue;
-    }
-    const merged = { address: existing.address };
-    const ens = existing.ens ?? entry.ens;
-    const name = existing.name ?? entry.name;
-    if (ens !== void 0) merged.ens = ens;
-    if (name !== void 0) merged.name = name;
-    byAddress.set(key, merged);
-  }
-  return [...byAddress.values()];
-}
-async function memberSnapshot(url) {
-  let res;
-  try {
-    res = await fetch(url);
-  } catch (error) {
-    throw new AssemblyIndexerUnavailableError({
-      code: "ASSEMBLY_INDEXER_UNAVAILABLE",
-      url,
-      reason: error instanceof Error ? error.message : String(error)
-    });
-  }
-  if (!res.ok) {
-    throw new AssemblyIndexerUnavailableError({
-      code: "ASSEMBLY_INDEXER_UNAVAILABLE",
-      url,
-      status: res.status,
-      statusText: res.statusText
-    });
-  }
-  const json = await res.json();
-  const parsed = memberSnapshotSchema.safeParse(json);
-  if (parsed.success) {
-    return mergeMemberIdentities(parsed.data.map(memberSnapshotEntryToIdentity));
-  }
-  throw new AssemblyApiValidationError({
-    code: "INVALID_ASSEMBLY_API_RESPONSE",
-    url,
-    issues: parsed.error.issues,
-    response: json
-  });
-}
-async function withTimeout(promise, timeoutMs, timeoutMessage) {
-  let timer;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise((_, reject) => {
-        timer = setTimeout(() => {
-          reject(new Error(timeoutMessage));
-        }, timeoutMs);
-      })
-    ]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-async function membersFromRegisteredEvents(client) {
-  const latestBlock = await client.getBlockNumber();
-  const addresses = /* @__PURE__ */ new Set();
-  for (let fromBlock = ABSTRACT_MAINNET_DEPLOYMENT_BLOCKS.registry; fromBlock <= latestBlock; fromBlock += REGISTERED_EVENT_SCAN_STEP) {
-    const toBlock = fromBlock + REGISTERED_EVENT_SCAN_STEP - 1n > latestBlock ? latestBlock : fromBlock + REGISTERED_EVENT_SCAN_STEP - 1n;
-    const events = await client.getContractEvents({
-      abi: registryAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.registry,
-      eventName: "Registered",
-      fromBlock,
-      toBlock,
-      strict: true
-    });
-    for (const event of events) {
-      const member = event.args.member;
-      if (typeof member === "string") {
-        addresses.add(member);
-      }
+    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
+      });
     }
-  }
-  return [...addresses].map((address) => ({ address }));
-}
-async function fetchMemberList(client, snapshotUrl) {
-  const url = snapshotUrl ?? DEFAULT_MEMBER_SNAPSHOT_URL;
-  try {
-    return { members: await memberSnapshot(url) };
-  } catch (error) {
-    if (error instanceof AssemblyApiValidationError) {
-      throw error;
+    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
+      });
     }
-    if (!(error instanceof AssemblyIndexerUnavailableError)) {
+    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;
     }
-    const fallbackMembers = await withTimeout(
-      membersFromRegisteredEvents(client),
-      REGISTERED_EVENT_SCAN_TIMEOUT_MS,
-      `Registered event fallback scan timed out after ${REGISTERED_EVENT_SCAN_TIMEOUT_MS}ms`
-    );
-    return {
-      members: mergeMemberIdentities(fallbackMembers),
-      fallbackReason: error.details
-    };
   }
-}
-async function fetchMemberOnchainState(client, addresses) {
-  if (addresses.length === 0) return [];
-  const calls = addresses.flatMap((address) => [
-    {
-      abi: registryAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.registry,
-      functionName: "isActive",
-      args: [address]
-    },
+});
+governance.command("execute", {
+  description: "Execute a queued governance proposal after timelock expiry.",
+  hint: "Requires PRIVATE_KEY environment variable for signing.",
+  args: z6.object({
+    proposalId: z6.coerce.number().int().positive().describe("Proposal id (1-indexed)")
+  }),
+  options: writeOptions,
+  env: writeEnv,
+  output: z6.object({
+    proposalId: z6.number(),
+    proposalTitle: z6.string(),
+    timelockEndsAt: timestampOutput3,
+    tx: txResultOutput3
+  }),
+  examples: [
     {
-      abi: registryAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.registry,
-      functionName: "members",
-      args: [address]
+      args: { proposalId: 1 },
+      description: "Execute proposal #1 after timelock has expired"
     }
-  ]);
-  const values = await client.multicall({ allowFailure: false, contracts: calls });
-  return addresses.map((address, i) => {
-    const active = values[i * 2];
-    const info = values[i * 2 + 1];
-    return {
-      address: toChecksum(address),
-      active,
-      registered: info.registered,
-      activeUntil: info.activeUntil,
-      lastHeartbeatAt: info.lastHeartbeatAt
-    };
-  });
-}
+  ],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const proposalCount = await fetchProposalCount(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 fetchProposalById(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,
+        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 as TxError3 } from "@spectratools/tx-shared";
+import { Cli as Cli4, z as z7 } from "incur";
 var DEFAULT_MEMBER_SNAPSHOT_URL2 = "https://www.theaiassembly.org/api/indexer/members";
 var MAX_MEMBER_LOOKUP_SUGGESTIONS = 5;
-var env4 = z6.object({
-  ABSTRACT_RPC_URL: z6.string().optional().describe("Abstract RPC URL override"),
-  ASSEMBLY_INDEXER_URL: z6.string().optional().describe("Optional members snapshot endpoint (default: theaiassembly.org indexer)")
+var env4 = z7.object({
+  ABSTRACT_RPC_URL: z7.string().optional().describe("Abstract RPC URL override"),
+  ASSEMBLY_INDEXER_URL: z7.string().optional().describe("Optional members snapshot endpoint (default: theaiassembly.org indexer)")
 });
-var timestampOutput4 = z6.union([z6.number(), z6.string()]);
+var timestampOutput4 = z7.union([z7.number(), z7.string()]);
 function matchableAddressInput(query) {
   return query.startsWith("0x") && query.length === 42;
 }
@@ -7079,19 +7633,19 @@ var members = Cli4.create("members", {
 members.command("list", {
   description: "List members from an indexer snapshot (or Registered event fallback) plus on-chain active state.",
   env: env4,
-  output: z6.object({
-    members: z6.array(
-      z6.object({
-        address: z6.string(),
-        active: z6.boolean(),
-        registered: z6.boolean(),
+  output: z7.object({
+    members: z7.array(
+      z7.object({
+        address: z7.string(),
+        active: z7.boolean(),
+        registered: z7.boolean(),
         activeUntil: timestampOutput4,
-        activeUntilRelative: z6.string(),
+        activeUntilRelative: z7.string(),
         lastHeartbeatAt: timestampOutput4,
-        lastHeartbeatRelative: z6.string()
+        lastHeartbeatRelative: z7.string()
       })
     ),
-    count: z6.number()
+    count: z7.number()
   }),
   examples: [
     { description: "List members using default indexer snapshot" },
@@ -7145,17 +7699,17 @@ members.command("list", {
 });
 members.command("info", {
   description: "Get member registry record and active status by full address, partial address, ENS, or name.",
-  args: z6.object({
-    address: z6.string().describe("Member lookup query (full/partial address, ENS, or name metadata)")
+  args: z7.object({
+    address: z7.string().describe("Member lookup query (full/partial address, ENS, or name metadata)")
   }),
   env: env4,
-  output: z6.object({
-    address: z6.string(),
-    active: z6.boolean(),
+  output: z7.object({
+    address: z7.string(),
+    active: z7.boolean(),
     activeUntil: timestampOutput4,
     lastHeartbeatAt: timestampOutput4,
-    activeUntilRelative: z6.string(),
-    lastHeartbeatRelative: z6.string()
+    activeUntilRelative: z7.string(),
+    lastHeartbeatRelative: z7.string()
   }),
   examples: [
     {
@@ -7240,9 +7794,9 @@ members.command("info", {
 members.command("count", {
   description: "Get active and total-known member counts from Registry.",
   env: env4,
-  output: z6.object({
-    active: z6.number(),
-    total: z6.number()
+  output: z7.object({
+    active: z7.number(),
+    total: z7.number()
   }),
   examples: [{ description: "Count active and known members" }],
   async run(c) {
@@ -7265,12 +7819,12 @@ members.command("count", {
 members.command("fees", {
   description: "Get registration and heartbeat fee settings.",
   env: env4,
-  output: z6.object({
-    registrationFeeWei: z6.string(),
-    registrationFee: z6.string(),
-    heartbeatFeeWei: z6.string(),
-    heartbeatFee: z6.string(),
-    heartbeatGracePeriodSeconds: z6.number()
+  output: z7.object({
+    registrationFeeWei: z7.string(),
+    registrationFee: z7.string(),
+    heartbeatFeeWei: z7.string(),
+    heartbeatFee: z7.string(),
+    heartbeatGracePeriodSeconds: z7.number()
   }),
   examples: [{ description: "Inspect current registry fee configuration" }],
   async run(c) {
@@ -7301,24 +7855,24 @@ members.command("fees", {
     });
   }
 });
-var txOutputSchema = z6.union([
-  z6.object({
-    status: z6.enum(["success", "reverted"]),
-    hash: z6.string(),
-    blockNumber: z6.number(),
-    gasUsed: z6.string(),
-    from: z6.string(),
-    to: z6.string().nullable(),
-    effectiveGasPrice: z6.string().optional(),
-    fee: z6.string(),
-    feeEth: z6.string()
+var txOutputSchema = z7.union([
+  z7.object({
+    status: z7.enum(["success", "reverted"]),
+    hash: z7.string(),
+    blockNumber: z7.number(),
+    gasUsed: z7.string(),
+    from: z7.string(),
+    to: z7.string().nullable(),
+    effectiveGasPrice: z7.string().optional(),
+    fee: z7.string(),
+    feeEth: z7.string()
   }),
-  z6.object({
-    status: z6.literal("dry-run"),
-    estimatedGas: z6.string(),
-    simulationResult: z6.unknown(),
-    fee: z6.string(),
-    feeEth: z6.string()
+  z7.object({
+    status: z7.literal("dry-run"),
+    estimatedGas: z7.string(),
+    simulationResult: z7.unknown(),
+    fee: z7.string(),
+    feeEth: z7.string()
   })
 ]);
 members.command("register", {
@@ -7475,49 +8029,109 @@ members.command("renew", {
   }
 });
 
+// src/commands/seats.ts
+import { Cli as Cli5, z as z8 } from "incur";
+var env5 = z8.object({
+  ABSTRACT_RPC_URL: z8.string().optional().describe("Abstract RPC URL override")
+});
+var timestampOutput5 = z8.union([z8.number(), z8.string()]);
+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 Cli5, z as z7 } from "incur";
+import { Cli as Cli6, z as z9 } from "incur";
 import { encodeAbiParameters, parseUnits, zeroAddress } from "viem";
-var env5 = z7.object({
-  ABSTRACT_RPC_URL: z7.string().optional().describe("Abstract RPC URL override")
+var env6 = z9.object({
+  ABSTRACT_RPC_URL: z9.string().optional().describe("Abstract RPC URL override")
 });
-var timestampOutput5 = z7.union([z7.number(), z7.string()]);
-var txResultOutput4 = z7.union([
-  z7.object({
-    status: z7.literal("success"),
-    hash: z7.string(),
-    blockNumber: z7.number(),
-    gasUsed: z7.string(),
-    from: z7.string(),
-    to: z7.string().nullable(),
-    effectiveGasPrice: z7.string().optional()
+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()
   }),
-  z7.object({
-    status: z7.literal("reverted"),
-    hash: z7.string(),
-    blockNumber: z7.number(),
-    gasUsed: z7.string(),
-    from: z7.string(),
-    to: z7.string().nullable(),
-    effectiveGasPrice: z7.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()
   }),
-  z7.object({
-    status: z7.literal("dry-run"),
-    estimatedGas: z7.string(),
-    simulationResult: z7.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: z7.object({
-    address: z7.string(),
-    balanceWei: z7.string(),
-    balance: z7.string()
+  env: env6,
+  output: z9.object({
+    address: z9.string(),
+    balanceWei: z9.string(),
+    balance: z9.string()
   }),
   examples: [{ description: "Check treasury balance" }],
   async run(c) {
@@ -7532,13 +8146,13 @@ treasury.command("balance", {
 });
 treasury.command("whitelist", {
   description: "Check whether an asset address is treasury-whitelisted.",
-  args: z7.object({
-    asset: z7.string().describe("Token/asset contract address")
+  args: z9.object({
+    asset: z9.string().describe("Token/asset contract address")
   }),
-  env: env5,
-  output: z7.object({
-    asset: z7.string(),
-    whitelisted: z7.boolean()
+  env: env6,
+  output: z9.object({
+    asset: z9.string(),
+    whitelisted: z9.boolean()
   }),
   examples: [
     {
@@ -7559,12 +8173,12 @@ treasury.command("whitelist", {
 });
 treasury.command("major-spend-status", {
   description: "Read major-spend cooldown status for the treasury contract.",
-  env: env5,
-  output: z7.object({
-    majorSpendCooldownSeconds: z7.number(),
-    lastMajorSpendAt: timestampOutput5,
-    lastMajorSpendRelative: z7.string(),
-    isMajorSpendAllowed: z7.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) {
@@ -7598,13 +8212,13 @@ treasury.command("major-spend-status", {
 });
 treasury.command("executed", {
   description: "Check whether a treasury action for a proposal has executed.",
-  args: z7.object({
-    proposalId: z7.coerce.number().int().positive().describe("Governance proposal id")
+  args: z9.object({
+    proposalId: z9.coerce.number().int().positive().describe("Governance proposal id")
   }),
-  env: env5,
-  output: z7.object({
-    proposalId: z7.number(),
-    executed: z7.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) {
@@ -7634,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: z7.string().describe("Token address to spend (use 0x0000000000000000000000000000000000000000 for ETH)"),
-    recipient: z7.string().describe("Recipient address"),
-    amount: z7.string().describe("Token amount as decimal string (human units)"),
-    decimals: z7.coerce.number().int().min(0).max(36).default(18).describe("Token decimals used to parse --amount (default: 18)"),
-    title: z7.string().min(1).describe("Proposal title"),
-    description: z7.string().min(1).describe("Proposal description"),
-    category: z7.string().default("treasury").describe("Forum category label for this proposal"),
-    "risk-tier": z7.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: z7.object({
-    proposer: z7.string(),
-    category: z7.string(),
-    token: z7.string(),
-    recipient: z7.string(),
-    amount: z7.string(),
-    amountWei: z7.string(),
-    expectedProposalId: z7.number(),
-    expectedThreadId: z7.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: [
@@ -7947,33 +8561,35 @@ 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);
-var rootEnv = z8.object({
-  ABSTRACT_RPC_URL: z8.string().optional().describe("Abstract RPC URL override")
+registerDigestCommand(cli);
+var rootEnv = z10.object({
+  ABSTRACT_RPC_URL: z10.string().optional().describe("Abstract RPC URL override")
 });
-var timestampOutput6 = z8.union([z8.number(), z8.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: z8.object({
-    activeMemberCount: z8.number(),
-    seatCount: z8.number(),
-    proposalCount: z8.number(),
-    currentAuctionDay: z8.number(),
-    currentAuctionSlot: z8.number(),
-    treasuryBalance: z8.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) {
-    return withCommandSpan("assembly status", {}, async () => {
+    return withCommandSpan2("assembly status", {}, async () => {
       const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
       const [
         activeMemberCount,
@@ -8023,18 +8639,18 @@ cli.command("status", {
 });
 cli.command("health", {
   description: "Check cross-contract health for one address (membership, council, refunds, power).",
-  args: z8.object({
-    address: z8.string().describe("Member or wallet address to inspect")
+  args: z10.object({
+    address: z10.string().describe("Member or wallet address to inspect")
   }),
   env: rootEnv,
-  output: z8.object({
-    address: z8.string(),
-    isActive: z8.boolean(),
-    activeUntil: timestampOutput6,
-    activeUntilRelative: z8.string(),
-    isCouncilMember: z8.boolean(),
-    pendingReturnsWei: z8.string(),
-    votingPower: z8.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: [
     {
@@ -8043,7 +8659,7 @@ cli.command("health", {
     }
   ],
   async run(c) {
-    return withCommandSpan("assembly health", { address: c.args.address }, async () => {
+    return withCommandSpan2("assembly health", { address: c.args.address }, async () => {
       const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
       const [isActive, member, isCouncilMember, pendingReturns, votingPower] = await Promise.all([
         client.readContract({