@spectratools/assembly-cli 0.11.7 → 0.13.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 z7 } from "incur";
+import { Cli as Cli6, z as z9 } from "incur";
 
 // src/commands/_common.ts
 import { checksumAddress, weiToEth } from "@spectratools/cli-shared";
@@ -5246,41 +5246,11 @@ council.command("withdraw-refund", {
   }
 });
 
-// src/commands/forum.ts
-import { TxError } from "@spectratools/tx-shared";
-import { Cli as Cli2, z as z3 } from "incur";
-var env2 = z3.object({
-  ABSTRACT_RPC_URL: z3.string().optional().describe("Abstract RPC URL override")
-});
-var commentEnv = env2.extend({
-  PRIVATE_KEY: z3.string().optional().describe("Private key (required only when posting a comment via --body)")
-});
-var timestampOutput2 = z3.union([z3.number(), z3.string()]);
-var txResultOutput2 = z3.union([
-  z3.object({
-    status: z3.literal("success"),
-    hash: z3.string(),
-    blockNumber: z3.number(),
-    gasUsed: z3.string(),
-    from: z3.string(),
-    to: z3.string().nullable(),
-    effectiveGasPrice: z3.string().optional()
-  }),
-  z3.object({
-    status: z3.literal("reverted"),
-    hash: z3.string(),
-    blockNumber: z3.number(),
-    gasUsed: z3.string(),
-    from: z3.string(),
-    to: z3.string().nullable(),
-    effectiveGasPrice: z3.string().optional()
-  }),
-  z3.object({
-    status: z3.literal("dry-run"),
-    estimatedGas: z3.string(),
-    simulationResult: z3.unknown()
-  })
-]);
+// src/commands/digest.ts
+import { withCommandSpan } from "@spectratools/cli-shared/telemetry";
+import { z as z4 } from "incur";
+
+// src/services/forum.ts
 function decodeThread(value) {
   const [id, kind, author, createdAt, category, title, body, proposalId, petitionId] = value;
   return {
@@ -5332,45 +5302,762 @@ function decodePetition(value) {
     proposalInput: jsonSafe(proposalInput)
   };
 }
+async function fetchAllThreads(client) {
+  const count = await client.readContract({
+    abi: forumAbi,
+    address: ABSTRACT_MAINNET_ADDRESSES.forum,
+    functionName: "threadCount"
+  });
+  const ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i + 1));
+  if (ids.length === 0) return [];
+  const threadTuples = await client.multicall({
+    allowFailure: false,
+    contracts: ids.map((id) => ({
+      abi: forumAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.forum,
+      functionName: "threads",
+      args: [id]
+    }))
+  });
+  return threadTuples.map(decodeThread);
+}
+async function fetchAllComments(client) {
+  const count = await client.readContract({
+    abi: forumAbi,
+    address: ABSTRACT_MAINNET_ADDRESSES.forum,
+    functionName: "commentCount"
+  });
+  const ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i + 1));
+  if (ids.length === 0) return [];
+  const commentTuples = await client.multicall({
+    allowFailure: false,
+    contracts: ids.map((id) => ({
+      abi: forumAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.forum,
+      functionName: "comments",
+      args: [id]
+    }))
+  });
+  return commentTuples.map(decodeComment);
+}
+async function fetchAllPetitions(client) {
+  const count = await client.readContract({
+    abi: forumAbi,
+    address: ABSTRACT_MAINNET_ADDRESSES.forum,
+    functionName: "petitionCount"
+  });
+  const ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i + 1));
+  if (ids.length === 0) return [];
+  const petitionTuples = await client.multicall({
+    allowFailure: false,
+    contracts: ids.map((id) => ({
+      abi: forumAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.forum,
+      functionName: "petitions",
+      args: [id]
+    }))
+  });
+  return petitionTuples.map(decodePetition);
+}
+async function fetchForumStats(client) {
+  const [threadCount, commentCount, petitionCount, petitionThresholdBps] = await Promise.all([
+    client.readContract({
+      abi: forumAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.forum,
+      functionName: "threadCount"
+    }),
+    client.readContract({
+      abi: forumAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.forum,
+      functionName: "commentCount"
+    }),
+    client.readContract({
+      abi: forumAbi,
+      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)
+  };
+}
+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 digestOutputSchema = z4.object({
+  meta: z4.object({
+    chainId: z4.number(),
+    fetchedAt: z4.string(),
+    address: z4.string().optional()
+  }),
+  proposals: z4.array(proposalDigestSchema),
+  threads: z4.array(threadDigestSchema),
+  comments: z4.array(commentDigestSchema),
+  petitions: z4.array(petitionDigestSchema),
+  members: z4.object({
+    count: z4.number(),
+    items: z4.array(memberItemSchema)
+  }),
+  errors: z4.array(z4.string())
+});
+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)")
+    }),
+    env: digestEnv,
+    output: digestOutputSchema,
+    examples: [
+      { description: "Fetch a full governance digest" },
+      {
+        options: { address: "0x230Ccc765765d729fFb1897D538f773b92005Aa2" },
+        description: "Fetch digest with wallet-relative enrichment"
+      }
+    ],
+    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;
+        const [proposalsResult, threadsResult, commentsResult, petitionsResult, membersResult] = await Promise.allSettled([
+          fetchAllProposals(client),
+          fetchAllThreads(client),
+          fetchAllComments(client),
+          fetchAllPetitions(client),
+          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 (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}`);
+        }
+        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
+              })}
+`
+            );
+          }
+        } else {
+          const err = membersResult.reason;
+          if (err instanceof AssemblyApiValidationError) {
+            errors.push(`members: ${err.details.code}`);
+          } else {
+            errors.push(`members: ${err}`);
+          }
+        }
+        let memberItems = [];
+        if (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 [votedResult, signedResult] = await Promise.allSettled([
+            fetchHasVotedBatch(
+              client,
+              address,
+              proposals.map((_, i) => i + 1)
+            ),
+            fetchHasSignedBatch(
+              client,
+              address,
+              petitions.map((p) => p.id)
+            )
+          ]);
+          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}`);
+          }
+        }
+        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;
+          }
+          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;
+          }
+          return entry;
+        });
+        const output = {
+          meta: {
+            chainId: 2741,
+            fetchedAt: (/* @__PURE__ */ new Date()).toISOString().replace(".000Z", "Z"),
+            ...address ? { address } : {}
+          },
+          proposals: serializedProposals,
+          threads: serializedThreads,
+          comments: serializedComments,
+          petitions: serializedPetitions,
+          members: {
+            count: memberItems.length,
+            items: memberItems
+          },
+          errors
+        };
+        return c.ok(output);
+      });
+    }
+  });
+}
+
+// src/commands/forum.ts
+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: z5.string().optional().describe("Private key (required only when posting a comment via --body)")
+});
+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()
+  }),
+  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()
+  }),
+  z5.object({
+    status: z5.literal("dry-run"),
+    estimatedGas: z5.string(),
+    simulationResult: z5.unknown()
+  })
+]);
 var forum = Cli2.create("forum", {
   description: "Browse Assembly forum threads, comments, and petitions."
 });
 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) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
-    const count = await client.readContract({
-      abi: forumAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.forum,
-      functionName: "threadCount"
-    });
-    const ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i + 1));
-    const threadTuples = ids.length ? await client.multicall({
-      allowFailure: false,
-      contracts: ids.map((id) => ({
-        abi: forumAbi,
-        address: ABSTRACT_MAINNET_ADDRESSES.forum,
-        functionName: "threads",
-        args: [id]
-      }))
-    }) : [];
-    const items = threadTuples.map(decodeThread);
+    const items = await fetchAllThreads(client);
     const threads = items.map((x) => ({
       id: x.id,
       kind: x.kind,
@@ -5399,13 +6086,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) {
@@ -5422,31 +6109,14 @@ forum.command("thread", {
         retryable: false
       });
     }
-    const [threadTuple, commentCount] = await Promise.all([
-      client.readContract({
-        abi: forumAbi,
-        address: ABSTRACT_MAINNET_ADDRESSES.forum,
-        functionName: "threads",
-        args: [BigInt(c.args.id)]
-      }),
-      client.readContract({
-        abi: forumAbi,
-        address: ABSTRACT_MAINNET_ADDRESSES.forum,
-        functionName: "commentCount"
-      })
-    ]);
+    const threadTuple = await client.readContract({
+      abi: forumAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.forum,
+      functionName: "threads",
+      args: [BigInt(c.args.id)]
+    });
     const thread = decodeThread(threadTuple);
-    const ids = Array.from({ length: Number(commentCount) }, (_, i) => BigInt(i + 1));
-    const commentTuples = ids.length ? await client.multicall({
-      allowFailure: false,
-      contracts: ids.map((id) => ({
-        abi: forumAbi,
-        address: ABSTRACT_MAINNET_ADDRESSES.forum,
-        functionName: "comments",
-        args: [id]
-      }))
-    }) : [];
-    const comments = commentTuples.map(decodeComment);
+    const comments = await fetchAllComments(client);
     return c.ok({
       thread: jsonSafe(thread),
       comments: comments.filter((x) => x.threadId === c.args.id).map((comment) => jsonSafe(comment))
@@ -5455,30 +6125,15 @@ 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);
-    const count = await client.readContract({
-      abi: forumAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.forum,
-      functionName: "commentCount"
-    });
-    const ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i + 1));
-    const commentTuples = ids.length ? await client.multicall({
-      allowFailure: false,
-      contracts: ids.map((id) => ({
-        abi: forumAbi,
-        address: ABSTRACT_MAINNET_ADDRESSES.forum,
-        functionName: "comments",
-        args: [id]
-      }))
-    }) : [];
-    const comments = commentTuples.map(decodeComment);
+    const comments = await fetchAllComments(client);
     return c.ok(
       comments.filter((x) => x.threadId === c.args.threadId).map((comment) => jsonSafe(comment))
     );
@@ -5486,15 +6141,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" },
     {
@@ -5609,16 +6264,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: [
@@ -5686,19 +6341,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: [
@@ -5785,20 +6440,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: [
@@ -5901,15 +6556,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" }],
@@ -5996,36 +6651,21 @@ 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);
-    const count = await client.readContract({
-      abi: forumAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.forum,
-      functionName: "petitionCount"
-    });
-    const ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i + 1));
-    const petitionTuples = ids.length ? await client.multicall({
-      allowFailure: false,
-      contracts: ids.map((id) => ({
-        abi: forumAbi,
-        address: ABSTRACT_MAINNET_ADDRESSES.forum,
-        functionName: "petitions",
-        args: [id]
-      }))
-    }) : [];
-    const petitions = petitionTuples.map(decodePetition);
+    const petitions = await fetchAllPetitions(client);
     return c.ok(petitions.map((petition) => jsonSafe(petition)));
   }
 });
 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);
@@ -6060,15 +6700,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: [
     {
@@ -6093,61 +6733,26 @@ 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) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
-    const [threadCount, commentCount, petitionCount, petitionThresholdBps] = await Promise.all([
-      client.readContract({
-        abi: forumAbi,
-        address: ABSTRACT_MAINNET_ADDRESSES.forum,
-        functionName: "threadCount"
-      }),
-      client.readContract({
-        abi: forumAbi,
-        address: ABSTRACT_MAINNET_ADDRESSES.forum,
-        functionName: "commentCount"
-      }),
-      client.readContract({
-        abi: forumAbi,
-        address: ABSTRACT_MAINNET_ADDRESSES.forum,
-        functionName: "petitionCount"
-      }),
-      client.readContract({
-        abi: forumAbi,
-        address: ABSTRACT_MAINNET_ADDRESSES.forum,
-        functionName: "petitionThresholdBps"
-      })
-    ]);
-    return c.ok({
-      threadCount: asNum(threadCount),
-      commentCount: asNum(commentCount),
-      petitionCount: asNum(petitionCount),
-      petitionThresholdBps: asNum(petitionThresholdBps)
-    });
+    return c.ok(await fetchForumStats(client));
   }
 });
 
 // src/commands/governance.ts
 import { TxError as TxError2 } from "@spectratools/tx-shared";
-import { Cli as Cli3, z as z4 } from "incur";
-var env3 = z4.object({
-  ABSTRACT_RPC_URL: z4.string().optional().describe("Abstract RPC URL override")
+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 proposalStatusLabels = {
-  0: "pending",
-  1: "active",
-  2: "passed",
-  3: "executed",
-  4: "defeated",
-  5: "cancelled"
-};
+var timestampOutput3 = z6.union([z6.number(), z6.string()]);
 var PROPOSAL_STATUS_PENDING = 0;
 var PROPOSAL_STATUS_ACTIVE = 1;
 var PROPOSAL_STATUS_PASSED = 2;
@@ -6156,176 +6761,56 @@ var supportChoiceToValue = {
   for: 1,
   abstain: 2
 };
-function proposalStatus(status) {
-  const statusCode = asNum(status);
-  return {
-    status: proposalStatusLabels[statusCode] ?? `unknown-${statusCode}`,
-    statusCode
-  };
-}
-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 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()
 });
-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 readProposalCount(client) {
-  return await client.readContract({
-    abi: governanceAbi,
-    address: ABSTRACT_MAINNET_ADDRESSES.governance,
-    functionName: "proposalCount"
-  });
-}
-async function readProposalById(client, proposalId) {
-  return decodeProposal(
-    await client.readContract({
-      abi: governanceAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.governance,
-      functionName: "proposals",
-      args: [BigInt(proposalId)]
-    })
-  );
-}
 var governance = Cli3.create("governance", {
   description: "Inspect Assembly governance proposals, votes, and parameters."
 });
 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()
-  }),
-  examples: [{ description: "List all proposals" }],
-  async run(c) {
-    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
-    const count = await client.readContract({
-      abi: governanceAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.governance,
-      functionName: "proposalCount"
-    });
-    const ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i + 1));
-    const proposalTuples = ids.length ? await client.multicall({
-      allowFailure: false,
-      contracts: ids.map((id) => ({
-        abi: governanceAbi,
-        address: ABSTRACT_MAINNET_ADDRESSES.governance,
-        functionName: "proposals",
-        args: [id]
-      }))
-    }) : [];
-    const proposals = proposalTuples.map(decodeProposal);
+    ),
+    count: z6.number()
+  }),
+  examples: [{ description: "List all proposals" }],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const proposals = await fetchAllProposals(client);
     const items = proposals.map((p, i) => ({
       ...proposalStatus(p.status),
       id: i + 1,
@@ -6356,19 +6841,15 @@ 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,
   examples: [{ args: { id: 1 }, description: "Fetch proposal #1" }],
   async run(c) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
-    const proposalCount = await client.readContract({
-      abi: governanceAbi,
-      address: ABSTRACT_MAINNET_ADDRESSES.governance,
-      functionName: "proposalCount"
-    });
+    const proposalCount = await fetchProposalCount(client);
     if (c.args.id > Number(proposalCount)) {
       return c.error({
         code: "OUT_OF_RANGE",
@@ -6376,28 +6857,21 @@ governance.command("proposal", {
         retryable: false
       });
     }
-    const proposal = decodeProposal(
-      await client.readContract({
-        abi: governanceAbi,
-        address: ABSTRACT_MAINNET_ADDRESSES.governance,
-        functionName: "proposals",
-        args: [BigInt(c.args.id)]
-      })
-    );
+    const proposal = await fetchProposalById(client, c.args.id);
     return c.ok(serializeProposal(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: [
     {
@@ -6426,19 +6900,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) {
@@ -6481,36 +6955,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: [
@@ -6527,7 +7001,7 @@ governance.command("vote", {
   async run(c) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
     const account = resolveAccount(c.env);
-    const proposalCount = await readProposalCount(client);
+    const proposalCount = await fetchProposalCount(client);
     if (c.args.proposalId > Number(proposalCount)) {
       return c.error({
         code: "OUT_OF_RANGE",
@@ -6535,7 +7009,7 @@ governance.command("vote", {
         retryable: false
       });
     }
-    const proposal = await readProposalById(client, c.args.proposalId);
+    const proposal = await fetchProposalById(client, c.args.proposalId);
     const status = proposalStatus(proposal.status);
     if (status.statusCode !== PROPOSAL_STATUS_ACTIVE) {
       return c.error({
@@ -6590,22 +7064,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: [
@@ -6648,7 +7122,7 @@ governance.command("propose", {
         retryable: false
       });
     }
-    const proposalCountBefore = await readProposalCount(client);
+    const proposalCountBefore = await fetchProposalCount(client);
     const expectedProposalId = Number(proposalCountBefore) + 1;
     const proposalInput = {
       kind: c.options.kind,
@@ -6694,15 +7168,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: [
@@ -6713,7 +7187,7 @@ governance.command("queue", {
   ],
   async run(c) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
-    const proposalCount = await readProposalCount(client);
+    const proposalCount = await fetchProposalCount(client);
     if (c.args.proposalId > Number(proposalCount)) {
       return c.error({
         code: "OUT_OF_RANGE",
@@ -6721,7 +7195,7 @@ governance.command("queue", {
         retryable: false
       });
     }
-    const proposal = await readProposalById(client, c.args.proposalId);
+    const proposal = await fetchProposalById(client, c.args.proposalId);
     const status = proposalStatus(proposal.status);
     if (status.statusCode === PROPOSAL_STATUS_PASSED) {
       return c.error({
@@ -6782,14 +7256,14 @@ governance.command("queue", {
 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)")
+  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(),
+  output: z6.object({
+    proposalId: z6.number(),
+    proposalTitle: z6.string(),
     timelockEndsAt: timestampOutput3,
     tx: txResultOutput3
   }),
@@ -6801,7 +7275,7 @@ governance.command("execute", {
   ],
   async run(c) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
-    const proposalCount = await readProposalCount(client);
+    const proposalCount = await fetchProposalCount(client);
     if (c.args.proposalId > Number(proposalCount)) {
       return c.error({
         code: "OUT_OF_RANGE",
@@ -6809,7 +7283,7 @@ governance.command("execute", {
         retryable: false
       });
     }
-    const proposal = await readProposalById(client, c.args.proposalId);
+    const proposal = await fetchProposalById(client, c.args.proposalId);
     const status = proposalStatus(proposal.status);
     if (status.statusCode !== PROPOSAL_STATUS_PASSED) {
       return c.error({
@@ -6856,64 +7330,14 @@ governance.command("execute", {
 
 // src/commands/members.ts
 import { TxError as TxError3 } from "@spectratools/tx-shared";
-import { Cli as Cli4, z as z5 } from "incur";
-var DEFAULT_MEMBER_SNAPSHOT_URL = "https://www.theaiassembly.org/api/indexer/members";
-var REGISTERED_EVENT_SCAN_STEP = 100000n;
-var REGISTERED_EVENT_SCAN_TIMEOUT_MS = 2e4;
+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 = z5.object({
-  ABSTRACT_RPC_URL: z5.string().optional().describe("Abstract RPC URL override"),
-  ASSEMBLY_INDEXER_URL: z5.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 = z5.union([z5.number(), z5.string()]);
-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 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()];
-}
-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;
-}
+var timestampOutput4 = z7.union([z7.number(), z7.string()]);
 function matchableAddressInput(query) {
   return query.startsWith("0x") && query.length === 42;
 }
@@ -6928,95 +7352,6 @@ function searchMemberIdentities(query, members2) {
     return member.address.toLowerCase().includes(needle) || member.ens?.toLowerCase().includes(needle) || member.name?.toLowerCase().includes(needle);
   });
 }
-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 loadMemberIdentities(client, snapshotUrl) {
-  try {
-    return { members: await memberSnapshot(snapshotUrl) };
-  } 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
-    };
-  }
-}
 function indexerIssue(details) {
   if (typeof details.status === "number") {
     return `${details.status}${details.statusText ? ` ${details.statusText}` : ""}`;
@@ -7048,19 +7383,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: z5.object({
-    members: z5.array(
-      z5.object({
-        address: z5.string(),
-        active: z5.boolean(),
-        registered: z5.boolean(),
+  output: z7.object({
+    members: z7.array(
+      z7.object({
+        address: z7.string(),
+        active: z7.boolean(),
+        registered: z7.boolean(),
         activeUntil: timestampOutput4,
-        activeUntilRelative: z5.string(),
+        activeUntilRelative: z7.string(),
         lastHeartbeatAt: timestampOutput4,
-        lastHeartbeatRelative: z5.string()
+        lastHeartbeatRelative: z7.string()
       })
     ),
-    count: z5.number()
+    count: z7.number()
   }),
   examples: [
     { description: "List members using default indexer snapshot" },
@@ -7068,11 +7403,11 @@ members.command("list", {
   ],
   async run(c) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
-    const snapshotUrl = c.env.ASSEMBLY_INDEXER_URL ?? DEFAULT_MEMBER_SNAPSHOT_URL;
+    const snapshotUrl = c.env.ASSEMBLY_INDEXER_URL ?? DEFAULT_MEMBER_SNAPSHOT_URL2;
     let memberIdentities;
     let fallbackReason;
     try {
-      const loaded = await loadMemberIdentities(client, snapshotUrl);
+      const loaded = await fetchMemberList(client, snapshotUrl);
       memberIdentities = loaded.members;
       fallbackReason = loaded.fallbackReason;
     } catch (error) {
@@ -7096,34 +7431,16 @@ members.command("list", {
       emitIndexerFallbackWarning(fallbackReason);
     }
     const addresses = memberIdentities.map((member) => member.address);
-    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 = calls.length > 0 ? await client.multicall({ allowFailure: false, contracts: calls }) : [];
-    const rows = addresses.map((address, i) => {
-      const active = values[i * 2];
-      const info = values[i * 2 + 1];
-      return {
-        address: toChecksum(address),
-        active,
-        registered: info.registered,
-        activeUntil: timeValue(info.activeUntil, c.format),
-        activeUntilRelative: relTime(info.activeUntil),
-        lastHeartbeatAt: timeValue(info.lastHeartbeatAt, c.format),
-        lastHeartbeatRelative: relTime(info.lastHeartbeatAt)
-      };
-    });
+    const onchainStates = await fetchMemberOnchainState(client, addresses);
+    const rows = onchainStates.map((state) => ({
+      address: state.address,
+      active: state.active,
+      registered: state.registered,
+      activeUntil: timeValue(state.activeUntil, c.format),
+      activeUntilRelative: relTime(state.activeUntil),
+      lastHeartbeatAt: timeValue(state.lastHeartbeatAt, c.format),
+      lastHeartbeatRelative: relTime(state.lastHeartbeatAt)
+    }));
     return c.ok({
       members: rows,
       count: rows.length
@@ -7132,17 +7449,17 @@ members.command("list", {
 });
 members.command("info", {
   description: "Get member registry record and active status by full address, partial address, ENS, or name.",
-  args: z5.object({
-    address: z5.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: z5.object({
-    address: z5.string(),
-    active: z5.boolean(),
+  output: z7.object({
+    address: z7.string(),
+    active: z7.boolean(),
     activeUntil: timestampOutput4,
     lastHeartbeatAt: timestampOutput4,
-    activeUntilRelative: z5.string(),
-    lastHeartbeatRelative: z5.string()
+    activeUntilRelative: z7.string(),
+    lastHeartbeatRelative: z7.string()
   }),
   examples: [
     {
@@ -7156,13 +7473,13 @@ members.command("info", {
   ],
   async run(c) {
     const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
-    const snapshotUrl = c.env.ASSEMBLY_INDEXER_URL ?? DEFAULT_MEMBER_SNAPSHOT_URL;
+    const snapshotUrl = c.env.ASSEMBLY_INDEXER_URL ?? DEFAULT_MEMBER_SNAPSHOT_URL2;
     let lookupAddress = c.args.address;
     if (!matchableAddressInput(c.args.address)) {
       let loadedMembers;
       let fallbackReason;
       try {
-        const loaded = await loadMemberIdentities(client, snapshotUrl);
+        const loaded = await fetchMemberList(client, snapshotUrl);
         loadedMembers = loaded.members;
         fallbackReason = loaded.fallbackReason;
       } catch (error) {
@@ -7227,9 +7544,9 @@ members.command("info", {
 members.command("count", {
   description: "Get active and total-known member counts from Registry.",
   env: env4,
-  output: z5.object({
-    active: z5.number(),
-    total: z5.number()
+  output: z7.object({
+    active: z7.number(),
+    total: z7.number()
   }),
   examples: [{ description: "Count active and known members" }],
   async run(c) {
@@ -7252,12 +7569,12 @@ members.command("count", {
 members.command("fees", {
   description: "Get registration and heartbeat fee settings.",
   env: env4,
-  output: z5.object({
-    registrationFeeWei: z5.string(),
-    registrationFee: z5.string(),
-    heartbeatFeeWei: z5.string(),
-    heartbeatFee: z5.string(),
-    heartbeatGracePeriodSeconds: z5.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) {
@@ -7288,24 +7605,24 @@ members.command("fees", {
     });
   }
 });
-var txOutputSchema = z5.union([
-  z5.object({
-    status: z5.enum(["success", "reverted"]),
-    hash: z5.string(),
-    blockNumber: z5.number(),
-    gasUsed: z5.string(),
-    from: z5.string(),
-    to: z5.string().nullable(),
-    effectiveGasPrice: z5.string().optional(),
-    fee: z5.string(),
-    feeEth: z5.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()
   }),
-  z5.object({
-    status: z5.literal("dry-run"),
-    estimatedGas: z5.string(),
-    simulationResult: z5.unknown(),
-    fee: z5.string(),
-    feeEth: z5.string()
+  z7.object({
+    status: z7.literal("dry-run"),
+    estimatedGas: z7.string(),
+    simulationResult: z7.unknown(),
+    fee: z7.string(),
+    feeEth: z7.string()
   })
 ]);
 members.command("register", {
@@ -7464,35 +7781,35 @@ members.command("renew", {
 
 // src/commands/treasury.ts
 import { TxError as TxError4 } from "@spectratools/tx-shared";
-import { Cli as Cli5, z as z6 } from "incur";
+import { Cli as Cli5, z as z8 } from "incur";
 import { encodeAbiParameters, parseUnits, zeroAddress } from "viem";
-var env5 = z6.object({
-  ABSTRACT_RPC_URL: z6.string().optional().describe("Abstract RPC URL override")
+var env5 = z8.object({
+  ABSTRACT_RPC_URL: z8.string().optional().describe("Abstract RPC URL override")
 });
-var timestampOutput5 = z6.union([z6.number(), z6.string()]);
-var txResultOutput4 = z6.union([
-  z6.object({
-    status: z6.literal("success"),
-    hash: z6.string(),
-    blockNumber: z6.number(),
-    gasUsed: z6.string(),
-    from: z6.string(),
-    to: z6.string().nullable(),
-    effectiveGasPrice: z6.string().optional()
+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()
   }),
-  z6.object({
-    status: z6.literal("reverted"),
-    hash: z6.string(),
-    blockNumber: z6.number(),
-    gasUsed: z6.string(),
-    from: z6.string(),
-    to: z6.string().nullable(),
-    effectiveGasPrice: z6.string().optional()
+  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()
   }),
-  z6.object({
-    status: z6.literal("dry-run"),
-    estimatedGas: z6.string(),
-    simulationResult: z6.unknown()
+  z8.object({
+    status: z8.literal("dry-run"),
+    estimatedGas: z8.string(),
+    simulationResult: z8.unknown()
   })
 ]);
 var treasury = Cli5.create("treasury", {
@@ -7501,10 +7818,10 @@ var treasury = Cli5.create("treasury", {
 treasury.command("balance", {
   description: "Get current native token balance for the treasury contract.",
   env: env5,
-  output: z6.object({
-    address: z6.string(),
-    balanceWei: z6.string(),
-    balance: z6.string()
+  output: z8.object({
+    address: z8.string(),
+    balanceWei: z8.string(),
+    balance: z8.string()
   }),
   examples: [{ description: "Check treasury balance" }],
   async run(c) {
@@ -7519,13 +7836,13 @@ treasury.command("balance", {
 });
 treasury.command("whitelist", {
   description: "Check whether an asset address is treasury-whitelisted.",
-  args: z6.object({
-    asset: z6.string().describe("Token/asset contract address")
+  args: z8.object({
+    asset: z8.string().describe("Token/asset contract address")
   }),
   env: env5,
-  output: z6.object({
-    asset: z6.string(),
-    whitelisted: z6.boolean()
+  output: z8.object({
+    asset: z8.string(),
+    whitelisted: z8.boolean()
   }),
   examples: [
     {
@@ -7547,11 +7864,11 @@ treasury.command("whitelist", {
 treasury.command("major-spend-status", {
   description: "Read major-spend cooldown status for the treasury contract.",
   env: env5,
-  output: z6.object({
-    majorSpendCooldownSeconds: z6.number(),
+  output: z8.object({
+    majorSpendCooldownSeconds: z8.number(),
     lastMajorSpendAt: timestampOutput5,
-    lastMajorSpendRelative: z6.string(),
-    isMajorSpendAllowed: z6.boolean()
+    lastMajorSpendRelative: z8.string(),
+    isMajorSpendAllowed: z8.boolean()
   }),
   examples: [{ description: "Inspect treasury major-spend guardrails" }],
   async run(c) {
@@ -7585,13 +7902,13 @@ treasury.command("major-spend-status", {
 });
 treasury.command("executed", {
   description: "Check whether a treasury action for a proposal has executed.",
-  args: z6.object({
-    proposalId: z6.coerce.number().int().positive().describe("Governance proposal id")
+  args: z8.object({
+    proposalId: z8.coerce.number().int().positive().describe("Governance proposal id")
   }),
   env: env5,
-  output: z6.object({
-    proposalId: z6.number(),
-    executed: z6.boolean()
+  output: z8.object({
+    proposalId: z8.number(),
+    executed: z8.boolean()
   }),
   examples: [{ args: { proposalId: 1 }, description: "Check execution status for proposal #1" }],
   async run(c) {
@@ -7621,25 +7938,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: z6.string().describe("Token address to spend (use 0x0000000000000000000000000000000000000000 for ETH)"),
-    recipient: z6.string().describe("Recipient address"),
-    amount: z6.string().describe("Token amount as decimal string (human units)"),
-    decimals: z6.coerce.number().int().min(0).max(36).default(18).describe("Token decimals used to parse --amount (default: 18)"),
-    title: z6.string().min(1).describe("Proposal title"),
-    description: z6.string().min(1).describe("Proposal description"),
-    category: z6.string().default("treasury").describe("Forum category label for this proposal"),
-    "risk-tier": z6.coerce.number().int().min(0).max(3).default(3).describe("Max allowed risk tier in intent constraints (0-3, default: 3)")
+    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)")
   }),
   env: writeEnv,
-  output: z6.object({
-    proposer: z6.string(),
-    category: z6.string(),
-    token: z6.string(),
-    recipient: z6.string(),
-    amount: z6.string(),
-    amountWei: z6.string(),
-    expectedProposalId: z6.number(),
-    expectedThreadId: z6.number(),
+  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(),
     tx: txResultOutput4
   }),
   examples: [
@@ -7943,24 +8260,25 @@ cli.command(council);
 cli.command(forum);
 cli.command(governance);
 cli.command(treasury);
-var rootEnv = z7.object({
-  ABSTRACT_RPC_URL: z7.string().optional().describe("Abstract RPC URL override")
+registerDigestCommand(cli);
+var rootEnv = z9.object({
+  ABSTRACT_RPC_URL: z9.string().optional().describe("Abstract RPC URL override")
 });
-var timestampOutput6 = z7.union([z7.number(), z7.string()]);
+var timestampOutput6 = z9.union([z9.number(), z9.string()]);
 cli.command("status", {
   description: "Get a cross-contract Assembly snapshot (members, council, governance, treasury).",
   env: rootEnv,
-  output: z7.object({
-    activeMemberCount: z7.number(),
-    seatCount: z7.number(),
-    proposalCount: z7.number(),
-    currentAuctionDay: z7.number(),
-    currentAuctionSlot: z7.number(),
-    treasuryBalance: z7.string()
+  output: z9.object({
+    activeMemberCount: z9.number(),
+    seatCount: z9.number(),
+    proposalCount: z9.number(),
+    currentAuctionDay: z9.number(),
+    currentAuctionSlot: z9.number(),
+    treasuryBalance: z9.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,
@@ -8010,18 +8328,18 @@ cli.command("status", {
 });
 cli.command("health", {
   description: "Check cross-contract health for one address (membership, council, refunds, power).",
-  args: z7.object({
-    address: z7.string().describe("Member or wallet address to inspect")
+  args: z9.object({
+    address: z9.string().describe("Member or wallet address to inspect")
   }),
   env: rootEnv,
-  output: z7.object({
-    address: z7.string(),
-    isActive: z7.boolean(),
+  output: z9.object({
+    address: z9.string(),
+    isActive: z9.boolean(),
     activeUntil: timestampOutput6,
-    activeUntilRelative: z7.string(),
-    isCouncilMember: z7.boolean(),
-    pendingReturnsWei: z7.string(),
-    votingPower: z7.number()
+    activeUntilRelative: z9.string(),
+    isCouncilMember: z9.boolean(),
+    pendingReturnsWei: z9.string(),
+    votingPower: z9.number()
   }),
   examples: [
     {
@@ -8030,7 +8348,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({