@sage-protocol/sdk 0.1.23 → 0.1.25

package/dist/node/index.cjs

@@ -14,7 +14,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.23",
+      version: "0.1.25",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -106,20 +106,21 @@ var require_abi = __commonJS({
     var SubDAO = [
       "function governor() view returns (address)",
       "function timelock() view returns (address)",
+      // SubDAO ops Safe / treasury (multisig) address. On newer deployments opsSafe() is an alias.
+      "function treasury() view returns (address)",
+      "function opsSafe() view returns (address)",
       "function getGovernanceMode() view returns (uint8)",
+      // New governance profile (3-axis model). May be unavailable on legacy SubDAOs.
+      "function profileInitialized() view returns (bool)",
+      "function getGovernanceProfile() view returns (uint8 kind, uint8 proposalAccess, uint8 executionAccess)",
       "function promptRegistry() view returns (address)",
       "function sageTreasury() view returns (address)",
-      "function stakeToken() view returns (address)",
-      "function minStakeAmount() view returns (uint256)",
       "function accessModel() view returns (uint8)",
       "function membershipPolicy() view returns (uint8)",
       "function profileCID() view returns (string)",
       "function factoryDeployer() view returns (address)",
-      "function stakedAmount(address) view returns (uint256)",
       "function userForkCount(address) view returns (uint256)",
       "function forkCount(string) view returns (uint256)",
-      "function stake(uint256)",
-      "function unstake(uint256)",
       // Fork functions
       "function forkSubDAO(string,string)",
       "function forkSubDAO(string,string,bool)",
@@ -159,7 +160,7 @@ var require_abi = __commonJS({
     var FactoryWrite = [
       "function createSubDAO(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount) returns (address subDAO, address registry)",
       "function createSubDAOWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
-      "function createSubDAOWithParams(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, uint256 votingDelay, uint256 votingPeriod, uint256 proposalThreshold, uint256 quorumPercentage, uint8 initialForkPolicy, uint8 initialMembershipPolicy, string profileCID) returns (address subDAO, address registry)",
+      "function createSubDAOWithParams(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, uint256 votingDelay, uint256 votingPeriod, uint256 proposalThreshold, uint256 quorumPercentage, uint8 initialForkPolicy, uint8 initialMembershipPolicy, string profileCID, string manifestCID, string manifestVersion) returns (address subDAO, address registry)",
       "function createSubDAOOperatorWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
       "function createSubDAOOperatorWithStableAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
       "function createSubDAOOperator(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin) returns (address subDAO, address registry)",
@@ -176,19 +177,21 @@ var require_abi = __commonJS({
       "function maxCreationBurn() view returns (uint256)"
     ];
     var LibraryRegistry = [
-      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee)",
+      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee, uint256 nonce)",
       "function daoTimelock(address) view returns (address)",
-      "function getLibrary(address) view returns (tuple(string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee))",
+      "function getLibrary(address) view returns (tuple(string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee, uint256 nonce))",
       "function getLibraryForkFee(address dao) view returns (uint256)",
       "function setLibraryForkFee(address dao, uint256 fee)",
       "function updateLibrary(address dao, string manifestCID, string version)",
+      "function updateLibraryCAS(address dao, string manifestCID, string version, uint256 expectedNonce)",
       "function registerDAO(address dao, address timelock)",
       "function registerForkedDAO(address childDAO, address childTimelock, address parentDAO, string manifestCID, string version)",
       "function initializeLibraryFromFork(address sourceDao, address forkedDao)",
-      "event LibraryUpdated(address indexed dao, string manifestCID, address indexed timelock, string version)",
+      "event LibraryUpdated(address indexed dao, string manifestCID, address indexed timelock, string version, uint256 nonce)",
       "event DAORegistered(address indexed dao, address indexed timelock)",
       "event LibraryForked(address indexed sourceDao, address indexed forkedDao, string manifestCID)",
-      "event LibraryForkFeeUpdated(address indexed dao, uint256 fee)"
+      "event LibraryForkFeeUpdated(address indexed dao, uint256 fee)",
+      "error NonceMismatch(uint256 expected, uint256 actual)"
     ];
     var PromptRegistry = [
       "function prompts(string key) view returns (string cid, uint256 version, uint256 timestamp, address author, string forkedFromCID, address originalAuthor, bool isFork, uint256 forkDepth)",
@@ -215,14 +218,23 @@ var require_abi = __commonJS({
     ];
     var Governor = [
       "function name() view returns (string)",
+      // ERC6372 clock (Governor uses this for vote snapshots)
+      "function clock() view returns (uint48)",
       "function timelock() view returns (address)",
       "function _executor() view returns (address)",
       "function sxxxToken() view returns (address)",
       "function votingDelay() view returns (uint256)",
       "function votingPeriod() view returns (uint256)",
       "function proposalThreshold() view returns (uint256)",
+      "function minVotesToVote() view returns (uint256)",
+      // OZ Governor: voting power at a past timepoint
+      "function getVotes(address,uint256) view returns (uint256)",
       // OZ Governor: quorum at a past block
       "function quorum(uint256) view returns (uint256)",
+      // Fixed quorumVotes model (PromptGovernor v2+)
+      "function quorumVotes() view returns (uint256)",
+      "function setQuorumVotes(uint256)",
+      // Legacy OZ Governor: percentage-based quorum (deprecated)
       "function quorumNumerator() view returns (uint256)",
       "function proposalStakeAmount(uint256) view returns (uint256)",
       "function state(uint256) view returns (uint8)",
@@ -235,9 +247,24 @@ var require_abi = __commonJS({
       "function castVoteWithReason(uint256 proposalId, uint8 support, string reason) returns (uint256)",
       "function queue(address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash)",
       "function execute(address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash)",
+      "function cancel(address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash) returns (uint256)",
       // Some Governors expose id-based queue/execute via TimelockController
       "function queue(uint256)",
-      "function execute(uint256)"
+      "function execute(uint256)",
+      // Threshold model (PromptGovernor)
+      "function proposalProposer(uint256 proposalId) view returns (address)",
+      "function proposalThresholdSnapshot(uint256 proposalId) view returns (uint256)",
+      "function proposalCreator(uint256 proposalId) view returns (address)",
+      "function proposalCooldown() view returns (uint256)",
+      "function lastProposalTimestamp(address) view returns (uint256)",
+      "function getProposalCooldownInfo(address) view returns (bool canPropose, uint256 cooldownRemaining)",
+      "function canCreateProposal(address) view returns (bool)",
+      "function setMinVotesToVote(uint256)",
+      // Multiplier helpers
+      "function baseVotesToken() view returns (address)",
+      "function isMultiplierEnabled() view returns (bool)",
+      "function multiplierNFT() view returns (address)",
+      "function getVotingBreakdown(address) view returns (uint256 baseVotes, uint256 multiplier, uint256 effectiveVotes)"
     ];
     var Timelock = [
       "function getMinDelay() view returns (uint256)",
@@ -457,13 +484,11 @@ var require_abi = __commonJS({
       "function governanceConfig() view returns (address)",
       "function communityTreasury() view returns (address)",
       "function governanceContract() view returns (address)",
-      "function libraryRegistry() view returns (address)",
       "function subdao() view returns (address)",
       "function soulboundBadge() view returns (address)",
       // Admin
       "function setGovernanceContract(address _gov)",
       "function setCommunityTreasury(address _treasury)",
-      "function setLibraryRegistry(address _registry)",
       "function setSoulboundBadge(address _sbtAddress)",
       "function grantRole(bytes32 role, address account)",
       "function revokeRole(bytes32 role, address account)",
@@ -477,7 +502,7 @@ var require_abi = __commonJS({
       "event VotingStarted(uint256 indexed bountyId, uint256 votingEndTime)",
       "event BountyCompleted(uint256 indexed bountyId, address indexed winner, uint256 reward, string deliverable)",
       "event BountyAutoApproved(uint256 indexed bountyId, address indexed winner)",
-      "event PromptAddedToLibrary(uint256 indexed bountyId, string libraryKey, string promptIPFS)",
+      "event BountyWinnerSelected(uint256 indexed bountyId, address indexed subdao, string libraryKey, string winnerCid, address indexed winner, uint8 libraryAction)",
       "event BountyCancelled(uint256 indexed bountyId, address indexed creator)",
       "event BountyExpired(uint256 indexed bountyId)",
       "event BountyRewardIncreased(uint256 indexed bountyId, uint256 additionalReward, uint256 newTotal)",
@@ -1571,193 +1596,496 @@ var require_transports = __commonJS({
   }
 });
 
-// src/browser/utils.js
-var require_utils = __commonJS({
-  "src/browser/utils.js"(exports2, module2) {
-    function getAddress(address) {
-      if (!address) return address;
-      const addr = String(address).trim();
-      const normalized = addr.startsWith("0x") ? addr.slice(2).toLowerCase() : addr.toLowerCase();
-      return `0x${normalized}`;
-    }
-    async function keccak256Async(data) {
-      const encoder = new TextEncoder();
-      const dataBuffer = typeof data === "string" ? encoder.encode(data) : data;
-      const hashBuffer = await crypto.subtle.digest("SHA-256", dataBuffer);
-      const hashArray = Array.from(new Uint8Array(hashBuffer));
-      const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-      return `0x${hashHex}`;
-    }
-    function keccak256Sync(data) {
-      const str = typeof data === "string" ? data : JSON.stringify(data);
-      let hash = 0;
-      for (let i = 0; i < str.length; i++) {
-        const char = str.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash = hash & hash;
+// src/utils/logs.js
+var require_logs = __commonJS({
+  "src/utils/logs.js"(exports2, module2) {
+    async function fetchLogsChunked({ provider, address, topics = [], fromBlock = 0, toBlock = "latest", chunkSize = 5e4 }) {
+      if (!provider) throw new Error("provider required");
+      const latest = toBlock === "latest" ? await provider.getBlockNumber() : Number(toBlock);
+      let start = Number(fromBlock);
+      const logs = [];
+      while (start <= latest) {
+        const end = Math.min(start + chunkSize - 1, latest);
+        const chunk = await provider.getLogs({ address, topics, fromBlock: start, toBlock: end });
+        logs.push(...chunk);
+        start = end + 1;
       }
-      const hex = Math.abs(hash).toString(16).padStart(8, "0");
-      return `0x${hex.repeat(8)}`.slice(0, 66);
+      return logs;
     }
     module2.exports = {
-      getAddress,
-      keccak256Async,
-      keccak256Sync
+      fetchLogsChunked
     };
   }
 });
 
-// src/browser/subgraph.js
-var require_subgraph2 = __commonJS({
-  "src/browser/subgraph.js"(exports2, module2) {
-    var { getAddress } = require_utils();
-    function sanitizeOrderBy(orderBy, allowed, fallback) {
-      const value = (orderBy || "").toString();
-      return allowed.includes(value) ? value : fallback;
-    }
-    function sanitizeOrderDirection(direction, fallback = "desc") {
-      const v = (direction || "").toString().toLowerCase();
-      return v === "asc" ? "asc" : "desc";
-    }
-    function safeGetAddress(value) {
+// src/subdao/index.js
+var require_subdao = __commonJS({
+  "src/subdao/index.js"(exports2, module2) {
+    var { Contract, Interface, getAddress } = require("ethers");
+    var ABI = require_abi();
+    var { fetchLogsChunked } = require_logs();
+    var { SageSDKError, CODES } = require_errors();
+    function normalise(address, label) {
+      if (!address) throw new SageSDKError(CODES.INVALID_ARGS, `${label} required`);
       try {
-        return getAddress(value);
-      } catch {
-        return null;
+        return getAddress(address);
+      } catch (err) {
+        throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
       }
     }
-    function mapSafe(list, mapper) {
+    async function discoverSubDAOs({ provider, factoryAddress, fromBlock = 0, toBlock = "latest", limit = 5e3, chunkSize = 5e4 }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const fac = normalise(factoryAddress, "factoryAddress");
+      const iface = new Interface(ABI.Factory);
+      const topic = iface.getEvent("SubDAOGovernanceDeployed").topicHash;
+      const logs = await fetchLogsChunked({ provider, address: fac, topics: [topic], fromBlock, toBlock, chunkSize });
       const out = [];
-      for (const item of list || []) {
+      const slice = limit > 0 ? logs.slice(-limit) : logs;
+      for (const log of slice) {
         try {
-          const v = mapper(item);
-          if (v != null) out.push(v);
-        } catch {
+          const decoded = iface.decodeEventLog("SubDAOGovernanceDeployed", log.data, log.topics);
+          out.push({
+            subdao: getAddress(decoded[0]),
+            governor: getAddress(decoded[1]),
+            timelock: getAddress(decoded[2]),
+            treasury: decoded[3] ? getAddress(decoded[3]) : null,
+            txHash: log.transactionHash,
+            blockNumber: log.blockNumber
+          });
+        } catch (err) {
+          continue;
         }
       }
       return out;
     }
-    async function query(url, document, variables) {
-      if (!url) throw new Error("subgraph url required");
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 1e4);
+    async function getSubDAOInfo({ provider, subdao }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const addr = normalise(subdao, "subdao");
+      const contract = new Contract(addr, ABI.SubDAO, provider);
+      const [governor, timelock, treasury, mode, promptRegistry, sageTreasury, accessModel, membershipPolicy, profileCID, factoryDeployer] = await Promise.all([
+        contract.governor(),
+        contract.timelock(),
+        // The ops Safe address (multisig) controlling treasury/admin ops.
+        contract.treasury().catch(() => null),
+        contract.getGovernanceMode().catch(() => null),
+        contract.promptRegistry().catch(() => null),
+        contract.sageTreasury().catch(() => null),
+        contract.accessModel().catch(() => null),
+        contract.membershipPolicy().catch(() => null),
+        contract.profileCID().catch(() => null),
+        contract.factoryDeployer().catch(() => null)
+      ]);
+      return {
+        address: addr,
+        governor: getAddress(governor),
+        timelock: getAddress(timelock),
+        treasury: treasury && treasury !== "0x0000000000000000000000000000000000000000" ? getAddress(treasury) : null,
+        governanceMode: mode,
+        promptRegistry: promptRegistry ? getAddress(promptRegistry) : null,
+        sageTreasury: sageTreasury ? getAddress(sageTreasury) : null,
+        accessModel: accessModel != null ? Number(accessModel) : null,
+        membershipPolicy: membershipPolicy != null ? Number(membershipPolicy) : null,
+        profileCID: profileCID || null,
+        factoryDeployer: factoryDeployer && factoryDeployer !== "0x0000000000000000000000000000000000000000" ? getAddress(factoryDeployer) : null
+      };
+    }
+    function decodeGovernanceProfile({ kind, proposalAccess, executionAccess }) {
+      const kindLabel = Number(kind) === 0 ? "OPERATOR" : Number(kind) === 1 ? "TOKEN" : null;
+      const proposalLabel = Number(proposalAccess) === 0 ? "COUNCIL_ONLY" : Number(proposalAccess) === 1 ? "COMMUNITY_THRESHOLD" : null;
+      const execLabel = Number(executionAccess) === 0 ? "COUNCIL_ONLY" : Number(executionAccess) === 1 ? "ANYONE" : null;
+      return {
+        kind: kindLabel,
+        proposalAccess: proposalLabel,
+        executionAccess: execLabel
+      };
+    }
+    async function getGovernanceProfile({ provider, subdao }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const addr = normalise(subdao, "subdao");
+      const contract = new Contract(addr, ABI.SubDAO, provider);
+      let profileInitialized = false;
+      let source = "legacy";
       try {
-        const resp = await fetch(url, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ query: document, variables }),
-          signal: controller.signal
-        });
-        clearTimeout(timeoutId);
-        if (!resp.ok) {
-          throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
-        }
-        const data = await resp.json();
-        if (data && data.errors) {
-          throw new Error(data.errors.map((e) => e.message).join("; "));
+        profileInitialized = !!await contract.profileInitialized();
+        source = profileInitialized ? "profile" : "legacy";
+      } catch (_) {
+        profileInitialized = false;
+        source = "legacy";
+      }
+      if (profileInitialized) {
+        try {
+          const [kind, proposalAccess, executionAccess] = await contract.getGovernanceProfile();
+          return {
+            ...decodeGovernanceProfile({ kind, proposalAccess, executionAccess }),
+            profileInitialized: true,
+            source
+          };
+        } catch (_) {
+          profileInitialized = false;
+          source = "legacy";
         }
-        return data.data;
-      } catch (error) {
-        clearTimeout(timeoutId);
-        throw error;
       }
-    }
-    async function listProposals({ url, governor, first = 20, skip = 0 }) {
-      const data = await query(url, `
-    query($governor: Bytes!, $first: Int!, $skip: Int!) {
-      proposals(where: { governor: $governor }, first: $first, skip: $skip, orderBy: createdAt, orderDirection: desc) {
-        id
-        proposer
-        description
-        createdAt
-        targets
-        values
-        calldatas
+      let mode = null;
+      try {
+        mode = await contract.getGovernanceMode();
+      } catch (_) {
       }
-    }
-  `, { governor: String(governor).toLowerCase(), first, skip });
-      return mapSafe(data?.proposals, (p) => {
-        const proposer = safeGetAddress(p.proposer);
-        if (!proposer) return null;
-        const targets = (p.targets || []).map((t) => safeGetAddress(t)).filter(Boolean);
-        if (!targets.length && (p.targets || []).length) return null;
+      if (mode != null && Number(mode) === 0) {
         return {
-          id: BigInt(p.id),
-          proposer,
-          description: p.description,
-          createdAt: Number(p.createdAt || 0),
-          targets,
-          values: (p.values || []).map((value) => BigInt(String(value))),
-          calldatas: p.calldatas || []
+          kind: "OPERATOR",
+          proposalAccess: "COUNCIL_ONLY",
+          executionAccess: "COUNCIL_ONLY",
+          profileInitialized: false,
+          source
         };
-      });
-    }
-    var STATE_STRING_TO_NUMBER = {
-      PENDING: 0,
-      ACTIVE: 1,
-      CANCELED: 2,
-      CANCELLED: 2,
-      // some indexes may use British spelling
-      DEFEATED: 3,
-      SUCCEEDED: 4,
-      QUEUED: 5,
-      EXPIRED: 6,
-      EXECUTED: 7
-    };
-    async function listProposalsFiltered({ url, governor, states, fromTimestamp, toTimestamp, first = 20, skip = 0, orderBy = "createdAt", orderDirection = "desc" }) {
-      const govLower = governor ? String(governor).toLowerCase() : null;
-      const statesUpper = Array.isArray(states) && states.length ? states.map((s) => String(s).toUpperCase()) : null;
-      const safeOrderBy = sanitizeOrderBy(orderBy, ["createdAt", "updatedAt", "eta"], "createdAt");
-      const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
-      const doc = `
-    query($first: Int!, $skip: Int!, $governor: Bytes, $states: [String!], $from: Int, $to: Int) {
-      proposals(
-        where: {
-          ${governor ? "governor: $governor," : ""}
-          ${statesUpper ? "state_in: $states," : ""}
-          ${fromTimestamp !== void 0 ? "createdAt_gte: $from," : ""}
-          ${toTimestamp !== void 0 ? "createdAt_lte: $to," : ""}
-        }
-        first: $first
-        skip: $skip
-        orderBy: ${safeOrderBy}
-        orderDirection: ${safeOrderDirection}
-      ) {
-        id
-        proposer
-        description
-        createdAt
-        updatedAt
-        state
-        eta
-        targets
-        values
-        calldatas
       }
-    }
-  `;
-      const variables = { first, skip };
-      if (govLower) variables.governor = govLower;
-      if (statesUpper) variables.states = statesUpper;
-      if (fromTimestamp !== void 0) variables.from = Number(fromTimestamp);
-      if (toTimestamp !== void 0) variables.to = Number(toTimestamp);
-      const data = await query(url, doc, variables);
-      return mapSafe(data?.proposals, (p) => {
-        const stateStr = String(p.state || "").toUpperCase();
-        const stateNum = STATE_STRING_TO_NUMBER[stateStr] != null ? STATE_STRING_TO_NUMBER[stateStr] : null;
-        const proposer = safeGetAddress(p.proposer);
-        if (!proposer) return null;
-        const targets = (p.targets || []).map((t) => safeGetAddress(t)).filter(Boolean);
-        if (!targets.length && (p.targets || []).length) return null;
+      if (mode != null && Number(mode) === 1) {
         return {
-          id: BigInt(p.id),
-          proposer,
-          description: p.description || "",
-          createdAt: Number(p.createdAt || 0),
-          updatedAt: Number(p.updatedAt || 0),
-          state: stateStr,
-          stateNum,
-          eta: p.eta ? BigInt(String(p.eta)) : null,
+          kind: "TOKEN",
+          proposalAccess: "COMMUNITY_THRESHOLD",
+          executionAccess: "ANYONE",
+          profileInitialized: false,
+          source
+        };
+      }
+      return {
+        kind: null,
+        proposalAccess: null,
+        executionAccess: null,
+        profileInitialized: false,
+        source
+      };
+    }
+    async function getSubDAOUserStats({ provider, subdao, account }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const addr = normalise(subdao, "subdao");
+      const user = normalise(account, "account");
+      const contract = new Contract(addr, ABI.SubDAO, provider);
+      const userForkCount = await contract.userForkCount(user).catch(() => 0n);
+      return {
+        userForkCount: Number(userForkCount)
+      };
+    }
+    var SubDAOInterface = new Interface([
+      // Optional on newer SubDAO implementations; provided for tx building only.
+      "function setProfileCid(string)"
+    ]);
+    function buildSetProfileCidTx({ subdao, profileCid }) {
+      const addr = normalise(subdao, "subdao");
+      if (!profileCid || typeof profileCid !== "string" || !profileCid.trim()) {
+        throw new SageSDKError(CODES.INVALID_ARGS, "profileCid (CID string) required");
+      }
+      const data = SubDAOInterface.encodeFunctionData("setProfileCid", [String(profileCid)]);
+      return { to: addr, data, value: 0n };
+    }
+    module2.exports = {
+      discoverSubDAOs,
+      getSubDAOInfo,
+      getGovernanceProfile,
+      getSubDAOUserStats,
+      buildSetProfileCidTx
+    };
+    async function ensureSxxxBurnAllowance({ signer, sxxx, owner, spender, amount }) {
+      if (!signer) throw new SageSDKError(CODES.INVALID_ARGS, "signer required");
+      if (!sxxx) throw new SageSDKError(CODES.INVALID_ARGS, "sxxx address required");
+      if (!spender) throw new SageSDKError(CODES.INVALID_ARGS, "spender (factory) required");
+      const sxxxAddr = getAddress(sxxx);
+      const spenderAddr = getAddress(spender);
+      const erc = new Contract(sxxxAddr, ABI.SXXX, signer);
+      const ownerAddr = owner ? getAddress(owner) : await signer.getAddress();
+      const need = BigInt(amount || 0n);
+      if (need === 0n) return { approved: false, tx: null };
+      const current = await erc.allowance(ownerAddr, spenderAddr);
+      const cur = BigInt(current.toString());
+      if (cur >= need) return { approved: false, tx: null };
+      const tx = await erc.approve(spenderAddr, need);
+      const rcpt = await tx.wait();
+      return { approved: true, tx, receipt: rcpt };
+    }
+    async function createSubDAO({ signer, factoryAddress, name, description, accessModel, burnAmount, sxxx }) {
+      if (!signer) throw new SageSDKError(CODES.INVALID_ARGS, "signer required");
+      if (!factoryAddress) throw new SageSDKError(CODES.INVALID_ARGS, "factoryAddress required");
+      const provider = signer.provider;
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "signer.provider required");
+      if (sxxx && BigInt(burnAmount || 0n) > 0n) {
+        await ensureSxxxBurnAllowance({ signer, sxxx, spender: factoryAddress, amount: BigInt(burnAmount) });
+      }
+      const fac = new Contract(getAddress(factoryAddress), ABI.FactoryWrite, signer);
+      const args = [
+        String(name || ""),
+        String(description || ""),
+        Number(accessModel ?? 0),
+        0n,
+        // minStakeAmount deprecated
+        BigInt(burnAmount ?? 0n)
+      ];
+      let tx;
+      try {
+        tx = await fac.createSubDAO(...args);
+      } catch (err) {
+        tx = await fac.createSubDAO(...args, { gasLimit: 8e6 });
+      }
+      const receipt = await tx.wait();
+      const iface = new Interface(ABI.Factory);
+      let subdao = null, governor = null, timelock = null, treasury = null, registry = null;
+      for (const log of receipt.logs || []) {
+        try {
+          const parsed = iface.parseLog(log);
+          if (parsed && parsed.name === "SubDAOGovernanceDeployed") {
+            subdao = getAddress(parsed.args.subDAO || parsed.args[0]);
+            governor = getAddress(parsed.args.governor || parsed.args[1]);
+            timelock = getAddress(parsed.args.timelock || parsed.args[2]);
+            treasury = getAddress(parsed.args.treasury || parsed.args[3]);
+          } else if (parsed && parsed.name === "SubDAOCreated") {
+            const maybe = parsed.args.registry || parsed.args[2];
+            if (maybe) registry = getAddress(maybe);
+            if (!subdao) subdao = getAddress(parsed.args.subDAO || parsed.args[0]);
+          }
+        } catch (_) {
+        }
+      }
+      try {
+        if (subdao && !registry) {
+          const sub = new Contract(subdao, ABI.SubDAO, provider);
+          const reg = await sub.promptRegistry().catch(() => null);
+          if (reg && /^0x/.test(String(reg))) registry = getAddress(reg);
+        }
+      } catch (_) {
+      }
+      return { tx, receipt, subdao, governor, timelock, treasury, registry };
+    }
+    async function makeOperator({ signer, subdao, operator, grantAdmin = false }) {
+      if (!signer) throw new SageSDKError(CODES.INVALID_ARGS, "signer required");
+      const provider = signer.provider;
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "signer.provider required");
+      const addr = normalise(subdao, "subdao");
+      const sub = new Contract(addr, ABI.SubDAO, provider);
+      const governor = getAddress(await sub.governor());
+      const timelock = getAddress(await sub.timelock());
+      const TL_ABI = [
+        "function PROPOSER_ROLE() view returns (bytes32)",
+        "function EXECUTOR_ROLE() view returns (bytes32)",
+        "function DEFAULT_ADMIN_ROLE() view returns (bytes32)",
+        "function grantRole(bytes32,address)",
+        "function revokeRole(bytes32,address)"
+      ];
+      const tl = new Contract(timelock, TL_ABI, signer);
+      const [PR, ER, AR] = await Promise.all([
+        tl.PROPOSER_ROLE(),
+        tl.EXECUTOR_ROLE(),
+        tl.DEFAULT_ADMIN_ROLE().catch(() => null)
+      ]);
+      const ops = [];
+      ops.push(await tl.grantRole(PR, getAddress(operator)));
+      ops.push(await tl.grantRole(ER, getAddress(operator)));
+      ops.push(await tl.revokeRole(PR, governor));
+      if (grantAdmin && AR) ops.push(await tl.grantRole(AR, getAddress(operator)));
+      const receipts = [];
+      for (const tx of ops) {
+        receipts.push(await tx.wait());
+      }
+      return { governor, timelock, operator: getAddress(operator), txs: ops, receipts };
+    }
+    async function createOperatorSubDAO({ signer, factoryAddress, operator, name, description, accessModel, burnAmount, sxxx, grantAdmin = false }) {
+      const created = await createSubDAO({ signer, factoryAddress, name, description, accessModel, burnAmount, sxxx });
+      if (!created.subdao) throw new SageSDKError(CODES.UNKNOWN, "createSubDAO did not emit SubDAO address");
+      const op = await makeOperator({ signer, subdao: created.subdao, operator, grantAdmin });
+      return { ...created, operatorResult: op };
+    }
+    module2.exports.ensureSxxxBurnAllowance = ensureSxxxBurnAllowance;
+    module2.exports.createSubDAO = createSubDAO;
+    module2.exports.makeOperator = makeOperator;
+    module2.exports.createOperatorSubDAO = createOperatorSubDAO;
+  }
+});
+
+// src/browser/utils.js
+var require_utils = __commonJS({
+  "src/browser/utils.js"(exports2, module2) {
+    function getAddress(address) {
+      if (!address) return address;
+      const addr = String(address).trim();
+      const normalized = addr.startsWith("0x") ? addr.slice(2).toLowerCase() : addr.toLowerCase();
+      return `0x${normalized}`;
+    }
+    async function keccak256Async(data) {
+      const encoder = new TextEncoder();
+      const dataBuffer = typeof data === "string" ? encoder.encode(data) : data;
+      const hashBuffer = await crypto.subtle.digest("SHA-256", dataBuffer);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+      return `0x${hashHex}`;
+    }
+    function keccak256Sync(data) {
+      const str = typeof data === "string" ? data : JSON.stringify(data);
+      let hash = 0;
+      for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash;
+      }
+      const hex = Math.abs(hash).toString(16).padStart(8, "0");
+      return `0x${hex.repeat(8)}`.slice(0, 66);
+    }
+    module2.exports = {
+      getAddress,
+      keccak256Async,
+      keccak256Sync
+    };
+  }
+});
+
+// src/browser/subgraph.js
+var require_subgraph2 = __commonJS({
+  "src/browser/subgraph.js"(exports2, module2) {
+    var { getAddress } = require_utils();
+    function sanitizeOrderBy(orderBy, allowed, fallback) {
+      const value = (orderBy || "").toString();
+      return allowed.includes(value) ? value : fallback;
+    }
+    function sanitizeOrderDirection(direction, fallback = "desc") {
+      const v = (direction || "").toString().toLowerCase();
+      return v === "asc" ? "asc" : "desc";
+    }
+    function safeGetAddress(value) {
+      try {
+        return getAddress(value);
+      } catch {
+        return null;
+      }
+    }
+    function mapSafe(list, mapper) {
+      const out = [];
+      for (const item of list || []) {
+        try {
+          const v = mapper(item);
+          if (v != null) out.push(v);
+        } catch {
+        }
+      }
+      return out;
+    }
+    async function query(url, document, variables) {
+      if (!url) throw new Error("subgraph url required");
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 1e4);
+      try {
+        const resp = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ query: document, variables }),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!resp.ok) {
+          throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+        }
+        const data = await resp.json();
+        if (data && data.errors) {
+          throw new Error(data.errors.map((e) => e.message).join("; "));
+        }
+        return data.data;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        throw error;
+      }
+    }
+    async function listProposals({ url, governor, first = 20, skip = 0 }) {
+      const data = await query(url, `
+    query($governor: Bytes!, $first: Int!, $skip: Int!) {
+      proposals(where: { governor: $governor }, first: $first, skip: $skip, orderBy: createdAt, orderDirection: desc) {
+        id
+        proposer
+        description
+        createdAt
+        targets
+        values
+        calldatas
+      }
+    }
+  `, { governor: String(governor).toLowerCase(), first, skip });
+      return mapSafe(data?.proposals, (p) => {
+        const proposer = safeGetAddress(p.proposer);
+        if (!proposer) return null;
+        const targets = (p.targets || []).map((t) => safeGetAddress(t)).filter(Boolean);
+        if (!targets.length && (p.targets || []).length) return null;
+        return {
+          id: BigInt(p.id),
+          proposer,
+          description: p.description,
+          createdAt: Number(p.createdAt || 0),
+          targets,
+          values: (p.values || []).map((value) => BigInt(String(value))),
+          calldatas: p.calldatas || []
+        };
+      });
+    }
+    var STATE_STRING_TO_NUMBER = {
+      PENDING: 0,
+      ACTIVE: 1,
+      CANCELED: 2,
+      CANCELLED: 2,
+      // some indexes may use British spelling
+      DEFEATED: 3,
+      SUCCEEDED: 4,
+      QUEUED: 5,
+      EXPIRED: 6,
+      EXECUTED: 7
+    };
+    async function listProposalsFiltered({ url, governor, states, fromTimestamp, toTimestamp, first = 20, skip = 0, orderBy = "createdAt", orderDirection = "desc" }) {
+      const govLower = governor ? String(governor).toLowerCase() : null;
+      const statesUpper = Array.isArray(states) && states.length ? states.map((s) => String(s).toUpperCase()) : null;
+      const safeOrderBy = sanitizeOrderBy(orderBy, ["createdAt", "updatedAt", "eta"], "createdAt");
+      const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
+      const doc = `
+    query($first: Int!, $skip: Int!, $governor: Bytes, $states: [String!], $from: Int, $to: Int) {
+      proposals(
+        where: {
+          ${governor ? "governor: $governor," : ""}
+          ${statesUpper ? "state_in: $states," : ""}
+          ${fromTimestamp !== void 0 ? "createdAt_gte: $from," : ""}
+          ${toTimestamp !== void 0 ? "createdAt_lte: $to," : ""}
+        }
+        first: $first
+        skip: $skip
+        orderBy: ${safeOrderBy}
+        orderDirection: ${safeOrderDirection}
+      ) {
+        id
+        proposer
+        description
+        createdAt
+        updatedAt
+        state
+        eta
+        targets
+        values
+        calldatas
+      }
+    }
+  `;
+      const variables = { first, skip };
+      if (govLower) variables.governor = govLower;
+      if (statesUpper) variables.states = statesUpper;
+      if (fromTimestamp !== void 0) variables.from = Number(fromTimestamp);
+      if (toTimestamp !== void 0) variables.to = Number(toTimestamp);
+      const data = await query(url, doc, variables);
+      return mapSafe(data?.proposals, (p) => {
+        const stateStr = String(p.state || "").toUpperCase();
+        const stateNum = STATE_STRING_TO_NUMBER[stateStr] != null ? STATE_STRING_TO_NUMBER[stateStr] : null;
+        const proposer = safeGetAddress(p.proposer);
+        if (!proposer) return null;
+        const targets = (p.targets || []).map((t) => safeGetAddress(t)).filter(Boolean);
+        if (!targets.length && (p.targets || []).length) return null;
+        return {
+          id: BigInt(p.id),
+          proposer,
+          description: p.description || "",
+          createdAt: Number(p.createdAt || 0),
+          updatedAt: Number(p.updatedAt || 0),
+          state: stateStr,
+          stateNum,
+          eta: p.eta ? BigInt(String(p.eta)) : null,
           targets,
           values: (p.values || []).map((value) => BigInt(String(value))),
           calldatas: p.calldatas || []
@@ -2192,6 +2520,7 @@ var require_ipfs = __commonJS({
     var FormData = require("form-data");
     var { ethers: ethers2 } = require("ethers");
     var DEFAULT_GATEWAY = "https://ipfs.dev.sageprotocol.io/ipfs";
+    var DEFAULT_WORKER_BASE = "https://api.sageprotocol.io";
     function toLowerSafe(value, fallback = "") {
       if (value == null) return fallback;
       try {
@@ -2263,7 +2592,8 @@ var require_ipfs = __commonJS({
       const formDataFactory = options.formDataFactory || (() => new FormData());
       const generateCid = options.generateCid || generateDeterministicCid;
       const config = {
-        provider: toLowerSafe(options.provider ?? env.SAGE_IPFS_PROVIDER ?? "auto"),
+        // Default to 'worker' to ensure uploads go through worker for indexing
+        provider: toLowerSafe(options.provider ?? env.SAGE_IPFS_PROVIDER ?? "worker"),
         gateway: options.gateway || env.SAGE_IPFS_GATEWAY || DEFAULT_GATEWAY,
         timeoutMs: Number(options.timeoutMs ?? env.SAGE_IPFS_TIMEOUT_MS ?? 15e3),
         retries: Math.max(0, Number(options.retries ?? env.SAGE_IPFS_RETRIES ?? 2)),
@@ -2276,11 +2606,12 @@ var require_ipfs = __commonJS({
           jwt: options.pinataJwt || env.PINATA_JWT || null
         },
         worker: {
-          baseUrl: removeTrailingSlash(options.workerBaseUrl || env.SAGE_IPFS_WORKER_URL || ""),
+          baseUrl: removeTrailingSlash(options.workerBaseUrl || env.SAGE_IPFS_WORKER_URL || DEFAULT_WORKER_BASE),
           uploadUrl: removeTrailingSlash(options.workerUploadUrl || env.SAGE_IPFS_UPLOAD_URL || ""),
           token: options.workerUploadToken || env.SAGE_IPFS_UPLOAD_TOKEN || "",
-          challengePath: options.workerChallengePath || env.SAGE_IPFS_WORKER_CHALLENGE_PATH || "/auth/challenge",
+          challengePath: options.workerChallengePath || env.SAGE_IPFS_WORKER_CHALLENGE_PATH || "/ipfs/auth/challenge",
           uploadPath: options.workerUploadPath || env.SAGE_IPFS_WORKER_UPLOAD_PATH || "/ipfs/upload",
+          uploadRawPath: options.workerUploadRawPath || env.SAGE_IPFS_WORKER_UPLOAD_RAW_PATH || "/ipfs/upload-raw",
           pinPath: options.workerPinPath || env.SAGE_IPFS_WORKER_PIN_PATH || "/ipfs/pin",
           warmPath: options.workerWarmPath || env.SAGE_IPFS_WORKER_WARM_PATH || "/ipfs/warm",
           pinUrl: removeTrailingSlash(options.workerPinUrl || env.SAGE_IPFS_WORKER_PIN_URL || ""),
@@ -2288,11 +2619,15 @@ var require_ipfs = __commonJS({
           signer: options.workerSigner || options.signer || null,
           getAuth: options.workerGetAuth || null,
           address: options.workerAddress || env.SAGE_SANDBOX_ADDRESS || "",
-          discoveryEventsPath: options.workerDiscoveryEventsPath || env.SAGE_IPFS_WORKER_DISCOVERY_EVENTS_PATH || "/discover/events",
-          discoveryMcpPath: options.workerDiscoveryMcpPath || env.SAGE_IPFS_WORKER_DISCOVERY_MCP_PATH || "/discover/mcp",
-          discoveryLaunchPath: options.workerDiscoveryLaunchPath || env.SAGE_IPFS_WORKER_DISCOVERY_LAUNCH_PATH || "/discover/launch",
+          // All event types route to /trends/usage - worker tracks usage for trend scoring
+          discoveryEventsPath: options.workerDiscoveryEventsPath || env.SAGE_IPFS_WORKER_DISCOVERY_EVENTS_PATH || "/trends/usage",
+          discoveryMcpPath: options.workerDiscoveryMcpPath || env.SAGE_IPFS_WORKER_DISCOVERY_MCP_PATH || "/trends/usage",
+          discoveryLaunchPath: options.workerDiscoveryLaunchPath || env.SAGE_IPFS_WORKER_DISCOVERY_LAUNCH_PATH || "/trends/usage",
+          // Install events track skill installations separately for trend scoring
+          discoveryInstallPath: options.workerDiscoveryInstallPath || env.SAGE_IPFS_WORKER_DISCOVERY_INSTALL_PATH || "/trends/install",
           discoveryFeedPath: options.workerDiscoveryFeedPath || env.SAGE_IPFS_WORKER_DISCOVERY_FEED_PATH || "/discover",
-          discoveryMetricsPath: options.workerDiscoveryMetricsPath || env.SAGE_IPFS_WORKER_DISCOVERY_METRICS_PATH || "/discover/metrics",
+          // Metrics uses /discover/stats which returns index statistics
+          discoveryMetricsPath: options.workerDiscoveryMetricsPath || env.SAGE_IPFS_WORKER_DISCOVERY_METRICS_PATH || "/discover/stats",
           governanceReportPath: options.workerGovernanceReportPath || env.SAGE_IPFS_WORKER_GOVERNANCE_REPORT_PATH || "/governance/report",
           governanceReportsPath: options.workerGovernanceReportsPath || env.SAGE_IPFS_WORKER_GOVERNANCE_REPORTS_PATH || "/governance/reports",
           governanceReviewPath: options.workerGovernanceReviewPath || env.SAGE_IPFS_WORKER_GOVERNANCE_REVIEW_PATH || "/governance/report/review",
@@ -2326,8 +2661,9 @@ var require_ipfs = __commonJS({
         const base = workerBaseUrl();
         const ensure = (path2) => path2.startsWith("/") ? path2 : `/${path2}`;
         if (base) {
-          if (kind === "challenge") return `${base}${ensure(config.worker.challengePath || "/auth/challenge")}`;
+          if (kind === "challenge") return `${base}${ensure(config.worker.challengePath || "/ipfs/auth/challenge")}`;
           if (kind === "upload") return `${base}${ensure(config.worker.uploadPath || "/ipfs/upload")}`;
+          if (kind === "upload-raw") return `${base}${ensure(config.worker.uploadRawPath || "/ipfs/upload-raw")}`;
           if (kind === "pin") return `${base}${ensure(config.worker.pinPath || "/ipfs/pin")}`;
           if (kind === "warm") return `${base}${ensure(config.worker.warmPath || "/ipfs/warm")}`;
           if (kind === "status") return `${base}${ensure(config.worker.pinPath || "/ipfs/pin")}/${cid}`;
@@ -2362,6 +2698,26 @@ var require_ipfs = __commonJS({
         const response = await axiosInstance.get(url, { headers, params, timeout: config.timeoutMs });
         return response?.data;
       }
+      async function withRetry(fn, { retries = 2, baseMs = 500 } = {}) {
+        let attempt = 0;
+        let lastErr;
+        while (attempt <= retries) {
+          try {
+            return await fn();
+          } catch (e) {
+            lastErr = e;
+            const status = e?.response?.status;
+            if (status && status >= 400 && status < 500 && status !== 429) {
+              throw e;
+            }
+            if (attempt === retries) break;
+            const delay = baseMs * Math.pow(2, attempt);
+            await new Promise((r) => setTimeout(r, delay));
+            attempt++;
+          }
+        }
+        throw lastErr;
+      }
       async function buildWorkerAuthHeaders(extraHeaders = {}) {
         if (config.worker.token) {
           return { headers: { ...extraHeaders, Authorization: `Bearer ${config.worker.token}` }, auth: null };
@@ -2404,9 +2760,7 @@ var require_ipfs = __commonJS({
         const hasEndpoint = workerBaseUrl() || config.worker.uploadUrl;
         if (!hasEndpoint) return false;
         if (!workerHasAuth()) return false;
-        if (config.provider === "worker") return true;
-        if (config.provider === "auto") return true;
-        return false;
+        return true;
       }
       function resolveProviderOrder(preference) {
         const order = [];
@@ -2422,8 +2776,8 @@ var require_ipfs = __commonJS({
           console.log("[SDK DEBUG] shouldUseWorker():", shouldUseWorker());
           console.log("[SDK DEBUG] hasPinataCreds():", hasPinataCreds());
         }
-        normalizedPreference.forEach(append);
         if (shouldUseWorker()) append("worker");
+        normalizedPreference.forEach(append);
         if (hasPinataCreds()) append("pinata");
         if (config.web3.token) append("web3");
         if (config.simulate) append("simulate");
@@ -2514,6 +2868,107 @@ var require_ipfs = __commonJS({
         }
         return result;
       }
+      async function uploadRawViaWorker(content, { name, warm, gateways } = {}) {
+        const uploadUrl = workerUrl("upload-raw");
+        if (process.env.SAGE_DEBUG_WORKER === "1") {
+          console.log("[SDK DEBUG] uploadRawViaWorker called");
+          console.log("[SDK DEBUG]   uploadUrl:", uploadUrl);
+        }
+        const { headers, auth } = await buildWorkerAuthHeaders({ "Content-Type": "application/json" });
+        const body = { content };
+        if (auth) body.auth = auth;
+        if (name) body.name = name;
+        if (process.env.SAGE_DEBUG_WORKER === "1") {
+          console.log("[SDK DEBUG]   headers:", Object.keys(headers));
+          console.log("[SDK DEBUG]   hasAuth:", !!auth);
+        }
+        let response;
+        try {
+          response = await axiosInstance.post(uploadUrl, body, { headers, timeout: config.timeoutMs });
+          if (process.env.SAGE_DEBUG_WORKER === "1") {
+            console.log("[SDK DEBUG] Upload response status:", response?.status);
+            console.log("[SDK DEBUG] Upload response data:", JSON.stringify(response?.data || {}));
+          }
+        } catch (uploadErr) {
+          if (process.env.SAGE_DEBUG_WORKER === "1") {
+            console.log("[SDK DEBUG] Upload error:", uploadErr.message);
+            console.log("[SDK DEBUG] Response status:", uploadErr.response?.status);
+            console.log("[SDK DEBUG] Response data:", JSON.stringify(uploadErr.response?.data || {}));
+          }
+          const status = uploadErr.response?.status;
+          const data2 = uploadErr.response?.data;
+          if (status === 400 && data2?.error === "content_blocked") {
+            const error = new Error("content_blocked");
+            error.code = "CONTENT_BLOCKED";
+            error.categories = data2.categories || [];
+            error.reason = data2.reason;
+            error.response = data2;
+            throw error;
+          }
+          if (status === 402) {
+            const error = new Error("payment_required");
+            error.code = "PAYMENT_REQUIRED";
+            error.creditsNeeded = data2?.creditsNeeded;
+            error.balance = data2?.balance;
+            error.accepts = data2?.accepts;
+            error.response = data2;
+            throw error;
+          }
+          throw uploadErr;
+        }
+        const data = response?.data || {};
+        const cid = data.cid || data.IpfsHash;
+        if (!cid) {
+          throw new Error("Worker response missing cid");
+        }
+        if (warm || config.shouldWarm) await warmGateways(cid, { gateways });
+        return {
+          cid,
+          provider: "worker",
+          response: data
+        };
+      }
+      async function uploadRawJson(content, options2 = {}) {
+        if (!content || typeof content !== "object") {
+          throw new Error("content object required");
+        }
+        const { providers, provider, warm, gateways, name = "manifest.json" } = options2;
+        const order = resolveProviderOrder(providers || provider);
+        if (!order.length) {
+          throw new Error("No IPFS providers configured");
+        }
+        const errors = [];
+        for (const candidate of order) {
+          try {
+            if (candidate === "worker") {
+              return await uploadRawViaWorker(content, { name, warm, gateways });
+            }
+            if (candidate === "pinata") {
+              if (process.env.SAGE_DEBUG_WORKER === "1") {
+                console.log("[SDK WARN] uploadRawJson falling back to pinata - content will be wrapped");
+              }
+              return await uploadToPinata(content, { filename: name, warm, gateways });
+            }
+            if (candidate === "web3") {
+              if (process.env.SAGE_DEBUG_WORKER === "1") {
+                console.log("[SDK WARN] uploadRawJson falling back to web3 - content will be wrapped");
+              }
+              return await uploadToWeb3Storage(content, { warm, gateways });
+            }
+            if (candidate === "simulate") {
+              return await uploadSimulated(content, { warm, gateways });
+            }
+          } catch (error2) {
+            if (error2.code === "CONTENT_BLOCKED" || error2.code === "PAYMENT_REQUIRED") {
+              throw error2;
+            }
+            errors.push({ provider: candidate, error: error2 });
+          }
+        }
+        const error = new Error("All IPFS providers failed");
+        error.details = errors;
+        throw error;
+      }
       async function uploadToPinata(payload, { filename = "payload.json", metadata, warm, gateways } = {}) {
         if (!hasPinataCreds()) {
           throw new Error("Missing Pinata credentials");
@@ -2742,28 +3197,37 @@ var require_ipfs = __commonJS({
       }
       async function recordDiscoveryEvent(event = {}) {
         if (!event || typeof event !== "object") throw new Error("event required");
-        const promptId = typeof event.promptId === "string" ? event.promptId.trim() : "";
-        if (!promptId) throw new Error("promptId required");
-        const payload = { ...event, promptId };
-        return postWorkerJson("discoveryEventsPath", "/discover/events", payload);
+        const cid = typeof event.promptId === "string" ? event.promptId.trim() : typeof event.cid === "string" ? event.cid.trim() : "";
+        if (!cid) throw new Error("promptId or cid required");
+        const payload = { ...event, cid };
+        return withRetry(() => postWorkerJson("discoveryEventsPath", "/trends/usage", payload));
+      }
+      async function recordMcpUsageEvent({ promptId, cid, metadata, address } = {}) {
+        const id2 = typeof promptId === "string" ? promptId.trim() : typeof cid === "string" ? cid.trim() : "";
+        if (!id2) throw new Error("promptId or cid required");
+        const payload = { cid: id2 };
+        if (metadata && typeof metadata === "object") payload.metadata = metadata;
+        const actor = address || config.worker.address;
+        if (actor) payload.address = actor;
+        return withRetry(() => postWorkerJson("discoveryMcpPath", "/trends/usage", payload));
       }
-      async function recordMcpUsageEvent({ promptId, metadata, address } = {}) {
-        const id2 = typeof promptId === "string" ? promptId.trim() : "";
-        if (!id2) throw new Error("promptId required");
-        const payload = { promptId: id2 };
+      async function recordLaunchEvent({ promptId, cid, metadata, address } = {}) {
+        const id2 = typeof promptId === "string" ? promptId.trim() : typeof cid === "string" ? cid.trim() : "";
+        if (!id2) throw new Error("promptId or cid required");
+        const payload = { cid: id2 };
         if (metadata && typeof metadata === "object") payload.metadata = metadata;
         const actor = address || config.worker.address;
         if (actor) payload.address = actor;
-        return postWorkerJson("discoveryMcpPath", "/discover/mcp", payload);
+        return withRetry(() => postWorkerJson("discoveryLaunchPath", "/trends/usage", payload));
       }
-      async function recordLaunchEvent({ promptId, metadata, address } = {}) {
-        const id2 = typeof promptId === "string" ? promptId.trim() : "";
-        if (!id2) throw new Error("promptId required");
-        const payload = { promptId: id2 };
+      async function recordInstallEvent({ skillCid, cid, metadata, address } = {}) {
+        const id2 = typeof skillCid === "string" ? skillCid.trim() : typeof cid === "string" ? cid.trim() : "";
+        if (!id2) throw new Error("skillCid or cid required");
+        const payload = { cid: id2 };
         if (metadata && typeof metadata === "object") payload.metadata = metadata;
         const actor = address || config.worker.address;
         if (actor) payload.address = actor;
-        return postWorkerJson("discoveryLaunchPath", "/discover/launch", payload);
+        return withRetry(() => postWorkerJson("discoveryInstallPath", "/trends/install", payload));
       }
       async function submitGovernanceReport(payload = {}) {
         if (!payload || typeof payload !== "object") throw new Error("payload required");
@@ -2825,6 +3289,7 @@ var require_ipfs = __commonJS({
         uploadPrompt,
         uploadJson,
         uploadText,
+        uploadRawJson,
         downloadJson,
         warmGateways,
         buildGatewayUrls: (cid, extra) => buildGatewayUrls(cid, config.gateway, extra),
@@ -2832,6 +3297,7 @@ var require_ipfs = __commonJS({
         recordDiscoveryEvent,
         recordMcpUsage: recordMcpUsageEvent,
         recordLaunchEvent,
+        recordInstallEvent,
         submitGovernanceReport,
         listGovernanceReports,
         reviewGovernanceReport,
@@ -2851,7 +3317,7 @@ var require_ipfs = __commonJS({
       const timeoutMs = Number(options.timeoutMs ?? env.SAGE_IPFS_TIMEOUT_MS ?? 15e3);
       const challengePath = ensureLeadingSlash(
         options.workerChallengePath || env.SAGE_IPFS_WORKER_CHALLENGE_PATH,
-        "/auth/challenge"
+        "/ipfs/auth/challenge"
       );
       const warmPath = ensureLeadingSlash(
         options.workerWarmPath || env.SAGE_IPFS_WORKER_WARM_PATH,
@@ -3383,7 +3849,10 @@ var require_library = __commonJS({
         proposer: getAddress(info.lastUpdater),
         promptCount: 0,
         // Not tracked on-chain in V4
-        version: info.version
+        version: info.version,
+        nonce: BigInt(info.nonce.toString()),
+        forkedFromDAO: info.forkedFromDAO && info.forkedFromDAO !== "0x0000000000000000000000000000000000000000" ? getAddress(info.forkedFromDAO) : null,
+        sxxxForkFee: BigInt(info.sxxxForkFee.toString())
       };
     }
     async function getManifestInfo({ provider, registry, manifestCID }) {
@@ -3419,6 +3888,21 @@ var require_library = __commonJS({
       ]);
       return { to, data, value: 0n };
     }
+    function buildUpdateLibraryCAS({ registry, subdao, manifestCID, version = "1.0.0", expectedNonce }) {
+      const to = normalise(registry, "registry");
+      if (!manifestCID) throw new SageSDKError(CODES.INVALID_ARGS, "manifestCID required");
+      if (expectedNonce === void 0 || expectedNonce === null) {
+        throw new SageSDKError(CODES.INVALID_ARGS, "expectedNonce required for CAS update");
+      }
+      const iface = new Interface(["function updateLibraryCAS(address,string,string,uint256)"]);
+      const data = iface.encodeFunctionData("updateLibraryCAS", [
+        normalise(subdao, "subdao"),
+        String(manifestCID),
+        String(version),
+        BigInt(expectedNonce)
+      ]);
+      return { to, data, value: 0n };
+    }
     module2.exports = {
       listManifests,
       getManifestInfo,
@@ -3426,6 +3910,7 @@ var require_library = __commonJS({
       getLatestLibrary,
       hasScopedOwnership,
       buildUpdateLibraryTx,
+      buildUpdateLibraryCAS,
       _computeLibraryKey,
       getBeforeAfterForUpdate,
       /** Build an authorizeTimelock(timelock, subdao) call for a LibraryRegistry. */
@@ -3444,73 +3929,305 @@ var require_library = __commonJS({
         const tgt = to ? normalise(to, "to") : reg;
         const from = normalise(timelock, "timelock");
         try {
-          await provider.call({ to: tgt, data, from });
-          return { ok: true };
-        } catch (err) {
-          return { ok: false, error: { type: "Revert", message: String(err && err.message || err) } };
+          await provider.call({ to: tgt, data, from });
+          return { ok: true };
+        } catch (err) {
+          return { ok: false, error: { type: "Revert", message: String(err && err.message || err) } };
+        }
+      },
+      executionReadiness: async function executionReadiness({ provider, registry, timelock, subdao, manifestCID = "", version = "1.0.0" }) {
+        if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+        const payload = buildUpdateLibraryTx({ registry, subdao, manifestCID, version });
+        const sim = await this.simulateAsTimelock({ provider, registry, to: payload.to, data: payload.data, timelock });
+        const out = { ok: !!sim.ok, error: sim.ok ? null : sim.error?.message || "revert", missingRole: null };
+        return out;
+      }
+    };
+  }
+});
+
+// src/governance/index.js
+var require_governance = __commonJS({
+  "src/governance/index.js"(exports2, module2) {
+    var { Contract, Interface, AbiCoder, ZeroAddress, getAddress, hexlify, keccak256, toUtf8Bytes } = require("ethers");
+    var ABI = require_abi();
+    var { BigIntZero } = require_types();
+    var { SageSDKError, CODES } = require_errors();
+    var { makeProposalDescription, stripProposalSalt } = require_description();
+    var subgraph = require_subgraph();
+    var adapters = require_transports();
+    var subdao = require_subdao();
+    function normaliseGovernor(governor) {
+      if (!governor) throw new SageSDKError(CODES.INVALID_ARGS, "governor required");
+      try {
+        return getAddress(governor);
+      } catch (err) {
+        throw new SageSDKError(CODES.INVALID_ARGS, "invalid governor address", { cause: err });
+      }
+    }
+    async function getGovernorInfo({ provider, governor }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const addr = normaliseGovernor(governor);
+      const g = new Contract(addr, ABI.Governor, provider);
+      const results = await Promise.all([
+        g.name().catch(() => null),
+        g.votingDelay().catch(() => null),
+        g.votingPeriod().catch(() => null),
+        g.proposalThreshold().catch(() => null),
+        g.timelock().catch(async () => {
+          try {
+            return await g._executor();
+          } catch {
+            return null;
+          }
+        }),
+        g.sxxxToken().catch(() => null),
+        // Try quorumVotes first (new fixed model), fall back to quorumNumerator (legacy OZ)
+        g.quorumVotes ? g.quorumVotes().catch(() => null) : null,
+        g.quorumNumerator ? g.quorumNumerator().catch(() => null) : null
+      ]);
+      const [name, votingDelay, votingPeriod, proposalThreshold, timelockRaw, sxxxToken, quorumVotes, quorumNumerator] = results;
+      const timelock = timelockRaw ? getAddress(timelockRaw) : null;
+      return {
+        address: addr,
+        name,
+        votingDelay,
+        votingPeriod,
+        proposalThreshold,
+        timelock,
+        sxxxToken: sxxxToken && /^0x/.test(String(sxxxToken)) ? getAddress(sxxxToken) : null,
+        // Primary: quorumVotes (fixed absolute amount)
+        quorumVotes,
+        // Legacy alias (deprecated)
+        quorumNumerator: quorumNumerator ?? quorumVotes
+      };
+    }
+    async function getGovernorTimepointMinusOne({ provider, governor }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const govAddr = normaliseGovernor(governor);
+      try {
+        const iface = new Interface(["function clock() view returns (uint48)"]);
+        const data = iface.encodeFunctionData("clock", []);
+        const ret = await provider.call({ to: govAddr, data });
+        if (ret && ret !== "0x") {
+          const [clk] = AbiCoder.defaultAbiCoder().decode(["uint48"], ret);
+          const now = BigInt(clk.toString());
+          return now > 0n ? now - 1n : 0n;
+        }
+      } catch (_) {
+      }
+      try {
+        const latest = await provider.getBlockNumber();
+        const now = BigInt(latest);
+        return now > 0n ? now - 1n : 0n;
+      } catch (_) {
+      }
+      return null;
+    }
+    async function getGovernorVotesAt({ provider, governor, account, timepoint }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!account) throw new SageSDKError(CODES.INVALID_ARGS, "account required");
+      if (timepoint == null) throw new SageSDKError(CODES.INVALID_ARGS, "timepoint required");
+      const govAddr = normaliseGovernor(governor);
+      const acct = getAddress(account);
+      const tp = typeof timepoint === "bigint" ? timepoint : BigInt(String(timepoint));
+      try {
+        const iface = new Interface(["function getVotes(address,uint256) view returns (uint256)"]);
+        const data = iface.encodeFunctionData("getVotes", [acct, tp]);
+        const ret = await provider.call({ to: govAddr, data });
+        if (ret && ret !== "0x") {
+          const [val] = AbiCoder.defaultAbiCoder().decode(["uint256"], ret);
+          return BigInt(val.toString());
+        }
+      } catch (_) {
+      }
+      try {
+        const { votingToken } = await resolveVotesTokenChain({ provider, governor: govAddr });
+        const tokenAddr = getAddress(votingToken);
+        const iface = new Interface(["function getPastVotes(address,uint256) view returns (uint256)"]);
+        const data = iface.encodeFunctionData("getPastVotes", [acct, tp]);
+        const ret = await provider.call({ to: tokenAddr, data });
+        if (ret && ret !== "0x") {
+          const [val] = AbiCoder.defaultAbiCoder().decode(["uint256"], ret);
+          return BigInt(val.toString());
+        }
+      } catch (_) {
+      }
+      return null;
+    }
+    async function getProposalThresholdStatus({ provider, governor, proposer }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!proposer) throw new SageSDKError(CODES.INVALID_ARGS, "proposer required");
+      const govAddr = normaliseGovernor(governor);
+      const user = getAddress(proposer);
+      const g = new Contract(govAddr, ABI.Governor, provider);
+      const [threshold, sxxxTokenAddr] = await Promise.all([
+        g.proposalThreshold().catch(() => null),
+        g.sxxxToken().catch(() => null)
+      ]);
+      const proposalThreshold = threshold != null ? BigInt(threshold.toString()) : null;
+      const sxxxToken = sxxxTokenAddr && /^0x[0-9a-fA-F]{40}$/.test(String(sxxxTokenAddr)) ? getAddress(sxxxTokenAddr) : null;
+      const votesTimepoint = await getGovernorTimepointMinusOne({ provider, governor: govAddr });
+      const proposerVotes = votesTimepoint != null ? await getGovernorVotesAt({ provider, governor: govAddr, account: user, timepoint: votesTimepoint }) : null;
+      let sxxxBalance = null;
+      if (sxxxToken) {
+        try {
+          const iface = new Interface(["function balanceOf(address) view returns (uint256)"]);
+          const data = iface.encodeFunctionData("balanceOf", [user]);
+          const ret = await provider.call({ to: sxxxToken, data });
+          if (ret && ret !== "0x") {
+            const [bal] = AbiCoder.defaultAbiCoder().decode(["uint256"], ret);
+            sxxxBalance = BigInt(bal.toString());
+          }
+        } catch (_) {
+        }
+      }
+      const thresholdMet = proposalThreshold != null && proposerVotes != null ? proposerVotes >= proposalThreshold : null;
+      let cooldownRemaining = null;
+      let canPropose = null;
+      try {
+        const iface = new Interface(["function getProposalCooldownInfo(address) view returns (bool canPropose, uint256 cooldownRemaining)"]);
+        const data = iface.encodeFunctionData("getProposalCooldownInfo", [user]);
+        const ret = await provider.call({ to: govAddr, data });
+        if (ret && ret !== "0x") {
+          const decoded = AbiCoder.defaultAbiCoder().decode(["bool", "uint256"], ret);
+          canPropose = decoded[0];
+          cooldownRemaining = BigInt(decoded[1].toString());
+        }
+      } catch (_) {
+        try {
+          const cooldownIface = new Interface(["function proposalCooldown() view returns (uint256)"]);
+          const lastIface = new Interface(["function lastProposalTimestamp(address) view returns (uint256)"]);
+          const [cooldownRet, lastRet] = await Promise.all([
+            provider.call({ to: govAddr, data: cooldownIface.encodeFunctionData("proposalCooldown", []) }).catch(() => null),
+            provider.call({ to: govAddr, data: lastIface.encodeFunctionData("lastProposalTimestamp", [user]) }).catch(() => null)
+          ]);
+          if (cooldownRet && cooldownRet !== "0x" && lastRet && lastRet !== "0x") {
+            const [cooldown] = AbiCoder.defaultAbiCoder().decode(["uint256"], cooldownRet);
+            const [last] = AbiCoder.defaultAbiCoder().decode(["uint256"], lastRet);
+            const block = await provider.getBlock("latest").catch(() => null);
+            if (block && block.timestamp != null) {
+              const now = BigInt(block.timestamp);
+              const endsAt = BigInt(last.toString()) + BigInt(cooldown.toString());
+              cooldownRemaining = endsAt > now ? endsAt - now : 0n;
+              canPropose = cooldownRemaining === 0n;
+            }
+          }
+        } catch (_2) {
+        }
+      }
+      const canProposeOverall = thresholdMet === true && (canPropose === true || canPropose === null);
+      return {
+        governor: govAddr,
+        proposer: user,
+        proposalThreshold,
+        sxxxToken,
+        sxxxBalance,
+        proposerVotes,
+        votesTimepoint,
+        thresholdMet,
+        cooldownRemaining,
+        cooldownElapsed: cooldownRemaining != null ? cooldownRemaining === 0n : null,
+        canPropose: canProposeOverall
+      };
+    }
+    async function getProposalCancelability({ provider, governor, proposalId }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (proposalId == null) throw new SageSDKError(CODES.INVALID_ARGS, "proposalId required");
+      const govAddr = normaliseGovernor(governor);
+      const pid = typeof proposalId === "bigint" ? proposalId : String(proposalId).startsWith("0x") ? BigInt(proposalId) : BigInt(String(proposalId));
+      let proposalProposer = null;
+      try {
+        const iface = new Interface(["function proposalProposer(uint256) view returns (address)"]);
+        const data = iface.encodeFunctionData("proposalProposer", [pid]);
+        const ret = await provider.call({ to: govAddr, data });
+        if (ret && ret !== "0x") {
+          const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], ret);
+          if (addr && /^0x[0-9a-fA-F]{40}$/.test(String(addr)) && addr !== ZeroAddress) {
+            proposalProposer = getAddress(addr);
+          }
+        }
+      } catch (_) {
+      }
+      let proposalCreator = null;
+      if (proposalProposer) {
+        proposalCreator = proposalProposer;
+      } else {
+        try {
+          const iface = new Interface(["function proposalCreator(uint256) view returns (address)"]);
+          const data = iface.encodeFunctionData("proposalCreator", [pid]);
+          const ret = await provider.call({ to: govAddr, data });
+          if (ret && ret !== "0x") {
+            const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], ret);
+            if (addr && /^0x[0-9a-fA-F]{40}$/.test(String(addr)) && addr !== ZeroAddress) {
+              proposalCreator = getAddress(addr);
+              proposalProposer = proposalCreator;
+            }
+          }
+        } catch (_) {
         }
-      },
-      executionReadiness: async function executionReadiness({ provider, registry, timelock, subdao, manifestCID = "", version = "1.0.0" }) {
-        if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-        const payload = buildUpdateLibraryTx({ registry, subdao, manifestCID, version });
-        const sim = await this.simulateAsTimelock({ provider, registry, to: payload.to, data: payload.data, timelock });
-        const out = { ok: !!sim.ok, error: sim.ok ? null : sim.error?.message || "revert", missingRole: null };
-        return out;
       }
-    };
-  }
-});
-
-// src/governance/index.js
-var require_governance = __commonJS({
-  "src/governance/index.js"(exports2, module2) {
-    var { Contract, Interface, AbiCoder, getAddress, hexlify, keccak256, toUtf8Bytes } = require("ethers");
-    var ABI = require_abi();
-    var { BigIntZero } = require_types();
-    var { SageSDKError, CODES } = require_errors();
-    var { makeProposalDescription, stripProposalSalt } = require_description();
-    var subgraph = require_subgraph();
-    var adapters = require_transports();
-    function normaliseGovernor(governor) {
-      if (!governor) throw new SageSDKError(CODES.INVALID_ARGS, "governor required");
+      let proposalThresholdSnapshot = null;
       try {
-        return getAddress(governor);
-      } catch (err) {
-        throw new SageSDKError(CODES.INVALID_ARGS, "invalid governor address", { cause: err });
+        const iface = new Interface(["function proposalThresholdSnapshot(uint256) view returns (uint256)"]);
+        const data = iface.encodeFunctionData("proposalThresholdSnapshot", [pid]);
+        const ret = await provider.call({ to: govAddr, data });
+        if (ret && ret !== "0x") {
+          const [val] = AbiCoder.defaultAbiCoder().decode(["uint256"], ret);
+          proposalThresholdSnapshot = BigInt(val.toString());
+        }
+      } catch (_) {
       }
-    }
-    async function getGovernorInfo({ provider, governor }) {
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normaliseGovernor(governor);
-      const g = new Contract(addr, ABI.Governor, provider);
-      const results = await Promise.all([
-        g.name().catch(() => null),
-        g.votingDelay().catch(() => null),
-        g.votingPeriod().catch(() => null),
+      const g = new Contract(govAddr, ABI.Governor, provider);
+      const [state, threshold, sxxxTokenAddr] = await Promise.all([
+        g.state(pid).catch(() => null),
         g.proposalThreshold().catch(() => null),
-        g.timelock().catch(async () => {
-          try {
-            return await g._executor();
-          } catch {
-            return null;
-          }
-        }),
-        g.sxxxToken().catch(() => null),
-        g.quorumNumerator ? g.quorumNumerator().catch(() => null) : null,
-        g.stakeAmount ? g.stakeAmount().catch(() => null) : null
+        g.sxxxToken().catch(() => null)
       ]);
-      const [name, votingDelay, votingPeriod, proposalThreshold, timelockRaw, sxxxToken, quorumNumerator, stakeAmount] = results;
-      const timelock = timelockRaw ? getAddress(timelockRaw) : null;
+      const proposalState = state != null ? Number(state) : null;
+      const proposalThresholdCurrent = threshold != null ? BigInt(threshold.toString()) : null;
+      const sxxxToken = sxxxTokenAddr && /^0x[0-9a-fA-F]{40}$/.test(String(sxxxTokenAddr)) ? getAddress(sxxxTokenAddr) : null;
+      const cancelThreshold = proposalThresholdSnapshot != null ? proposalThresholdSnapshot : proposalThresholdCurrent;
+      const votesTimepoint = await getGovernorTimepointMinusOne({ provider, governor: govAddr });
+      const proposerVotes = proposalProposer && votesTimepoint != null ? await getGovernorVotesAt({ provider, governor: govAddr, account: proposalProposer, timepoint: votesTimepoint }) : null;
+      let proposerBalance = null;
+      if (proposalProposer && sxxxToken) {
+        try {
+          const iface = new Interface(["function balanceOf(address) view returns (uint256)"]);
+          const data = iface.encodeFunctionData("balanceOf", [proposalProposer]);
+          const ret = await provider.call({ to: sxxxToken, data });
+          if (ret && ret !== "0x") {
+            const [bal] = AbiCoder.defaultAbiCoder().decode(["uint256"], ret);
+            proposerBalance = BigInt(bal.toString());
+          }
+        } catch (_) {
+        }
+      }
+      const cancelableStates = /* @__PURE__ */ new Set([0, 1]);
+      const isInCancelableState = proposalState != null && cancelableStates.has(proposalState);
+      const proposerBelowThreshold = cancelThreshold != null && proposerVotes != null ? proposerVotes < cancelThreshold : null;
+      const isCancelableByAnyone = isInCancelableState && proposerBelowThreshold === true;
       return {
-        address: addr,
-        name,
-        votingDelay,
-        votingPeriod,
-        proposalThreshold,
-        timelock,
-        sxxxToken: sxxxToken && /^0x/.test(String(sxxxToken)) ? getAddress(sxxxToken) : null,
-        quorumNumerator,
-        stakeAmount
+        governor: govAddr,
+        proposalId: pid,
+        proposalProposer,
+        proposalCreator,
+        proposalState,
+        proposalThresholdSnapshot,
+        proposalThresholdCurrent,
+        cancelThreshold,
+        sxxxToken,
+        proposerBalance,
+        votesTimepoint,
+        proposerVotes,
+        proposerBelowThreshold,
+        isInCancelableState,
+        isCancelableByAnyone,
+        cancelReason: isCancelableByAnyone ? "Proposer voting power dropped below proposal threshold" : isInCancelableState ? "Only proposer can cancel (above threshold)" : "Proposal not in cancelable state",
+        // Backward-compat aliases
+        proposalThreshold: cancelThreshold,
+        creatorBalance: proposerBalance,
+        creatorBelowThreshold: proposerBelowThreshold
       };
     }
     async function getProposal({ provider, governor, id: id2 }) {
@@ -3707,6 +4424,7 @@ var require_governance = __commonJS({
     }
     var buildQueueTx = (args) => cueTx("queue(address[],uint256[],bytes[],bytes32)", args);
     var buildExecuteTx = (args) => cueTx("execute(address[],uint256[],bytes[],bytes32)", args);
+    var buildCancelTx = (args) => cueTx("cancel(address[],uint256[],bytes[],bytes32)", args);
     function buildQueueByIdTx({ governor, proposalId }) {
       const addr = normaliseGovernor(governor);
       const iface = new Interface(ABI.Governor);
@@ -3853,6 +4571,47 @@ var require_governance = __commonJS({
       }
       return 0n;
     }
+    async function getVotesLatestMinusOneWithTimepoint({ provider, token, governor, account }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!token && !governor) throw new SageSDKError(CODES.INVALID_ARGS, "token or governor required");
+      if (!account) throw new SageSDKError(CODES.INVALID_ARGS, "account required");
+      let addr;
+      if (token) {
+        addr = getAddress(token);
+      } else {
+        const govAddr = normaliseGovernor(governor);
+        try {
+          const chain = await resolveVotesTokenChain({ provider, governor: govAddr });
+          addr = getAddress(chain.votingToken);
+        } catch (err) {
+          throw new SageSDKError(CODES.NOT_FOUND, "failed to resolve votes token from governor", { cause: err });
+        }
+      }
+      const user = getAddress(account);
+      const latest = await provider.getBlockNumber();
+      const timepoint = latest > 0 ? BigInt(latest - 1) : 0n;
+      try {
+        const iface = new Interface(["function getPastVotes(address,uint256) view returns (uint256)"]);
+        const data = iface.encodeFunctionData("getPastVotes", [user, timepoint]);
+        const ret = await provider.call({ to: addr, data });
+        if (ret && ret !== "0x") {
+          const [val] = AbiCoder.defaultAbiCoder().decode(["uint256"], ret);
+          return { votes: BigInt(val.toString()), timepoint };
+        }
+      } catch (_) {
+      }
+      try {
+        const iface2 = new Interface(["function getVotes(address) view returns (uint256)"]);
+        const d2 = iface2.encodeFunctionData("getVotes", [user]);
+        const ret2 = await provider.call({ to: addr, data: d2 });
+        if (ret2 && ret2 !== "0x") {
+          const [val2] = AbiCoder.defaultAbiCoder().decode(["uint256"], ret2);
+          return { votes: BigInt(val2.toString()), timepoint };
+        }
+      } catch (_) {
+      }
+      return { votes: 0n, timepoint };
+    }
     async function simulatePropose({ provider, governor, targets = [], values = [], calldatas = [], description = "", sender }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normaliseGovernor(governor);
@@ -3902,13 +4661,18 @@ var require_governance = __commonJS({
     async function buildDelegateSelfTx({ provider, governor, account }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const govAddr = normaliseGovernor(governor);
-      const g = new Contract(govAddr, ABI.Governor, provider);
-      const token = await g.sxxxToken();
-      return buildDelegateTx({ token, delegatee: account });
+      try {
+        const { baseToken } = await resolveVotesTokenChain({ provider, governor: govAddr });
+        return buildDelegateTx({ token: baseToken, delegatee: account });
+      } catch (_) {
+        const g = new Contract(govAddr, ABI.Governor, provider);
+        const token = await g.sxxxToken();
+        return buildDelegateTx({ token, delegatee: account });
+      }
     }
-    async function resolveVotesTokenChain({ provider, subdao, governor }) {
+    async function resolveVotesTokenChain({ provider, subdao: subdao2, governor }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      if (!subdao && !governor) throw new SageSDKError(CODES.INVALID_ARGS, "subdao or governor required");
+      if (!subdao2 && !governor) throw new SageSDKError(CODES.INVALID_ARGS, "subdao or governor required");
       let votingToken = null;
       if (governor) {
         const govAddr = normaliseGovernor(governor);
@@ -3935,19 +4699,6 @@ var require_governance = __commonJS({
           }
         }
       }
-      if (!votingToken && subdao) {
-        try {
-          const subAddr = getAddress(subdao);
-          const iSub = new Interface(["function stakeToken() view returns (address)"]);
-          const d3 = iSub.encodeFunctionData("stakeToken", []);
-          const r3 = await provider.call({ to: subAddr, data: d3 });
-          if (r3 && r3 !== "0x") {
-            const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], r3);
-            votingToken = addr;
-          }
-        } catch (_) {
-        }
-      }
       if (!votingToken) {
         throw new SageSDKError(CODES.NOT_FOUND, "failed to resolve votes token");
       }
@@ -3968,7 +4719,7 @@ var require_governance = __commonJS({
           const [decodedDao] = AbiCoder.defaultAbiCoder().decode(["address"], rawDao);
           const baseNorm = getAddress(decodedBase);
           const daoNorm = getAddress(decodedDao);
-          if (!subdao || daoNorm === getAddress(subdao)) {
+          if (!subdao2 || daoNorm === getAddress(subdao2)) {
             baseToken = baseNorm;
             isWrapper = true;
           }
@@ -3977,8 +4728,8 @@ var require_governance = __commonJS({
       }
       return { votingToken: votingTokenNorm, baseToken, isWrapper };
     }
-    async function describeVotesToken({ provider, subdao, governor }) {
-      const { votingToken, baseToken, isWrapper } = await resolveVotesTokenChain({ provider, subdao, governor });
+    async function describeVotesToken({ provider, subdao: subdao2, governor }) {
+      const { votingToken, baseToken, isWrapper } = await resolveVotesTokenChain({ provider, subdao: subdao2, governor });
       let multiplierNFT = null;
       let basis = null;
       if (isWrapper) {
@@ -3999,8 +4750,8 @@ var require_governance = __commonJS({
       } else {
         const basisStr = basisBig != null ? basisBig.toString() : "10000";
         description = `Voting token = MultipliedVotes(base=${baseNorm}, multiplierNFT=${multiplierNorm || "unknown"}, BASIS=${basisStr})`;
-        if (subdao) {
-          description += ` for DAO ${getAddress(subdao)}`;
+        if (subdao2) {
+          description += ` for DAO ${getAddress(subdao2)}`;
         }
       }
       return {
@@ -4012,9 +4763,9 @@ var require_governance = __commonJS({
         description
       };
     }
-    async function getVotingStatus({ provider, subdao, governor, account }) {
+    async function getVotingStatus({ provider, subdao: subdao2, governor, account }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      if (!governor && !subdao) throw new SageSDKError(CODES.INVALID_ARGS, "governor or subdao required");
+      if (!governor && !subdao2) throw new SageSDKError(CODES.INVALID_ARGS, "governor or subdao required");
       if (!account) throw new SageSDKError(CODES.INVALID_ARGS, "account required");
       const acct = getAddress(account);
       let govAddr = null;
@@ -4022,8 +4773,8 @@ var require_governance = __commonJS({
       if (governor) {
         govAddr = normaliseGovernor(governor);
       }
-      if (subdao) {
-        subdaoAddr = getAddress(subdao);
+      if (subdao2) {
+        subdaoAddr = getAddress(subdao2);
         if (!govAddr) {
           try {
             const sub = new Contract(subdaoAddr, ["function governor() view returns (address)"], provider);
@@ -4041,17 +4792,6 @@ var require_governance = __commonJS({
       } catch (_) {
       }
       const desc = await describeVotesToken({ provider, subdao: subdaoAddr || void 0, governor: govAddr });
-      let stakeToken = null;
-      if (subdaoAddr) {
-        try {
-          const sub = new Contract(subdaoAddr, ["function stakeToken() view returns (address)"], provider);
-          const st = await sub.stakeToken();
-          if (st && /^0x[0-9a-fA-F]{40}$/.test(String(st))) {
-            stakeToken = getAddress(st);
-          }
-        } catch (_) {
-        }
-      }
       const VotesABI = [
         "function getVotes(address) view returns (uint256)",
         "function delegates(address) view returns (address)",
@@ -4071,28 +4811,9 @@ var require_governance = __commonJS({
       } catch (_) {
       }
       const canPropose = threshold != null && votingPower != null ? votingPower >= threshold : null;
-      let stakeTokenVotes = null;
-      let stakeTokenDelegate = null;
-      let stakeTokenBalance = null;
-      const tokenMismatch = !!stakeToken && stakeToken.toLowerCase() !== desc.votingToken.toLowerCase();
-      if (stakeToken && tokenMismatch) {
-        try {
-          const stakeC = new Contract(stakeToken, VotesABI, provider);
-          const sv = await stakeC.getVotes(acct).catch(() => null);
-          if (sv != null) stakeTokenVotes = BigInt(sv.toString());
-          const sd = await stakeC.delegates(acct).catch(() => null);
-          if (sd && /^0x[0-9a-fA-F]{40}$/.test(String(sd))) {
-            stakeTokenDelegate = getAddress(sd);
-          }
-          const sb = await stakeC.balanceOf(acct).catch(() => null);
-          if (sb != null) stakeTokenBalance = BigInt(sb.toString());
-        } catch (_) {
-        }
-      }
       return {
         subdao: subdaoAddr,
         governor: govAddr,
-        stakeToken,
         votingToken: desc.votingToken,
         baseToken: desc.baseToken,
         isWrapper: desc.isWrapper,
@@ -4103,10 +4824,6 @@ var require_governance = __commonJS({
         tokenBalance,
         delegate,
         canPropose,
-        tokenMismatch,
-        stakeTokenVotes,
-        stakeTokenDelegate,
-        stakeTokenBalance,
         description: desc.description
       };
     }
@@ -4120,6 +4837,7 @@ var require_governance = __commonJS({
       buildCastVoteTx,
       buildQueueTx,
       buildExecuteTx,
+      buildCancelTx,
       buildQueueByIdTx,
       buildExecuteByIdTx,
       decodeProposalEffects,
@@ -4132,16 +4850,19 @@ var require_governance = __commonJS({
       buildDelegateSelfTx,
       computeProposalIdHex,
       getVotesLatestMinusOne,
+      getVotesLatestMinusOneWithTimepoint,
       simulatePropose,
+      // Threshold model (PromptGovernor)
+      getProposalThresholdStatus,
+      getProposalCancelability,
       /**
        * Resolve the IVotes token used for governance voting.
        * Preference order:
        * - Governor.token() (if exposed)
        * - Governor.sxxxToken()
-       * - SubDAO.stakeToken() (when subdao provided)
        */
-      resolveVotesToken: async function resolveVotesToken({ provider, subdao, governor }) {
-        const { votingToken } = await resolveVotesTokenChain({ provider, subdao, governor });
+      resolveVotesToken: async function resolveVotesToken({ provider, subdao: subdao2, governor }) {
+        const { votingToken } = await resolveVotesTokenChain({ provider, subdao: subdao2, governor });
         return votingToken;
       },
       /**
@@ -4158,20 +4879,20 @@ var require_governance = __commonJS({
        */
       getVotingStatus,
       /** Build a delegate(self) tx using the preferred votes token resolution path. */
-      buildDelegateSelfPreferred: async function buildDelegateSelfPreferred({ provider, subdao, governor, account }) {
+      buildDelegateSelfPreferred: async function buildDelegateSelfPreferred({ provider, subdao: subdao2, governor, account }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
         if (!account) throw new SageSDKError(CODES.INVALID_ARGS, "account required");
-        const { baseToken } = await resolveVotesTokenChain({ provider, subdao, governor });
+        const { baseToken } = await resolveVotesTokenChain({ provider, subdao: subdao2, governor });
         return buildDelegateTx({ token: baseToken, delegatee: account });
       },
       /**
        * Send a delegate(self) and verify votes at latest-1.
        * If signer is omitted, returns payload and current votes without sending.
        */
-      delegateSelfAndVerify: async function delegateSelfAndVerify({ provider, subdao, governor, account, signer = null, minVotes = null }) {
+      delegateSelfAndVerify: async function delegateSelfAndVerify({ provider, subdao: subdao2, governor, account, signer = null, minVotes = null }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
         if (!account) throw new SageSDKError(CODES.INVALID_ARGS, "account required");
-        const { votingToken, baseToken } = await resolveVotesTokenChain({ provider, subdao, governor });
+        const { votingToken, baseToken } = await resolveVotesTokenChain({ provider, subdao: subdao2, governor });
         const payload = buildDelegateTx({ token: baseToken, delegatee: account });
         let txHash = null;
         if (signer && typeof signer.sendTransaction === "function") {
@@ -4184,7 +4905,8 @@ var require_governance = __commonJS({
         return { txHash, ok, votes, payload };
       },
       /**
-       * Ensure propose gates based on threshold, cooldown (best-effort), stake+allowance, and votes at latest-1.
+       * Ensure propose gates based on THRESHOLD MODEL (votes-based threshold + cooldown).
+       * No stake or allowance checks - proposer just needs sufficient voting power at clock()-1.
        * Returns a non-throwing summary.
        */
       ensureProposeGates: async function ensureProposeGates({ provider, governor, proposer }) {
@@ -4192,90 +4914,488 @@ var require_governance = __commonJS({
         const govAddr = normaliseGovernor(governor);
         const user = getAddress(proposer);
         const g = new Contract(govAddr, ABI.Governor, provider);
-        const threshold = await g.proposalThreshold().catch(() => null);
-        let cooldown = null;
-        try {
-          const i = new Interface(["function proposalCooldown() view returns (uint256)"]);
-          const r = await provider.call({ to: govAddr, data: i.encodeFunctionData("proposalCooldown", []) });
-          if (r && r !== "0x") cooldown = BigInt(AbiCoder.defaultAbiCoder().decode(["uint256"], r)[0].toString());
-        } catch (_) {
+        const status = await getProposalThresholdStatus({ provider, governor: govAddr, proposer: user });
+        return {
+          // Core threshold model
+          threshold: status.proposalThreshold,
+          sxxxBalance: status.sxxxBalance,
+          thresholdMet: status.thresholdMet,
+          cooldownRemaining: status.cooldownRemaining,
+          cooldownElapsed: status.cooldownElapsed,
+          canPropose: status.canPropose,
+          // Voting power (canonical: clock()-1)
+          votesTimepoint: status.votesTimepoint,
+          votingPower: status.proposerVotes,
+          votesOk: status.thresholdMet,
+          // Details
+          details: { sxxxToken: status.sxxxToken, proposer: user, governor: govAddr },
+          cooldown: status.cooldownRemaining
+          // alias for cooldownRemaining
+        };
+      },
+      /**
+       * Compose propose readiness with optional execution readiness checks.
+       * execution?: { provider, registry, timelock, subdao, manifestCID, version }
+       */
+      readinessToPropose: async function readinessToPropose({ provider, governor, proposer, execution = null }) {
+        const gates = await this.ensureProposeGates({ provider, governor, proposer });
+        let executionReady = null;
+        let executionError = null;
+        if (execution && execution.registry && execution.timelock && execution.subdao) {
+          try {
+            const library = require_library();
+            const { to, data } = library.buildUpdateLibraryTx({
+              registry: execution.registry,
+              subdao: execution.subdao,
+              manifestCID: execution.manifestCID || "",
+              version: execution.version || "1.0.0"
+            });
+            const sim = await library.simulateAsTimelock({ provider, registry: execution.registry, to, data, timelock: execution.timelock });
+            executionReady = !!sim.ok;
+            executionError = sim.ok ? null : sim.error?.message || "revert";
+          } catch (err) {
+            executionReady = false;
+            executionError = String(err && err.message || err);
+          }
         }
-        let stakeRequired = null;
-        try {
-          const i2 = new Interface(["function proposalStakeRequired() view returns (uint256)"]);
-          const r2 = await provider.call({ to: govAddr, data: i2.encodeFunctionData("proposalStakeRequired", []) });
-          if (r2 && r2 !== "0x") stakeRequired = BigInt(AbiCoder.defaultAbiCoder().decode(["uint256"], r2)[0].toString());
-        } catch (_) {
+        return { ...gates, executionReady, executionError };
+      },
+      /**
+       * Unified authority + readiness envelope for agent-native governance UX.
+       *
+       * This is intentionally **read-only**: it returns diagnostics and optional tx payloads/CLI commands,
+       * but never sends transactions.
+       *
+       * Inputs:
+       * - provider (required)
+       * - subdao OR governor (required)
+       * - account (optional, enables per-account readiness checks)
+       * - action: propose | vote | queue | execute | timelock-schedule | update-library
+       * - proposalId (optional, for queue/execute diagnostics)
+       * - libraryRegistry / dao / manifestCID / version (optional, for update-library diagnostics)
+       */
+      getAuthorityAndReadiness: async function getAuthorityAndReadiness({
+        provider,
+        subdao: subdaoAddress = null,
+        governor: governorAddress = null,
+        account = null,
+        action,
+        proposalId = null,
+        libraryRegistry = null,
+        dao = null,
+        manifestCID = null,
+        version = null
+      } = {}) {
+        if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+        if (!subdaoAddress && !governorAddress) throw new SageSDKError(CODES.INVALID_ARGS, "subdao or governor required");
+        const actionNorm = String(action || "propose").trim().toLowerCase();
+        const allowed = /* @__PURE__ */ new Set(["propose", "vote", "queue", "execute", "timelock-schedule", "update-library"]);
+        if (!allowed.has(actionNorm)) {
+          throw new SageSDKError(CODES.INVALID_ARGS, `unsupported action: ${String(action || "")}`);
+        }
+        const readiness = [];
+        const push = (item) => readiness.push(item);
+        const normalizeAccount = () => {
+          if (!account) return null;
+          try {
+            return getAddress(account);
+          } catch (err) {
+            throw new SageSDKError(CODES.INVALID_ARGS, "invalid account address", { cause: err });
+          }
+        };
+        const acct = normalizeAccount();
+        const proposal = {
+          proposalThreshold: null,
+          sxxxToken: null,
+          proposerSxxxBalance: null,
+          thresholdMet: null,
+          cooldownRemaining: null,
+          cooldownElapsed: null,
+          proposerVotes: null,
+          votesTimepoint: null,
+          cancelPolicy: {
+            enabled: null,
+            cancelableStates: ["Pending", "Active"],
+            thresholdSource: "proposalThresholdSnapshot",
+            note: "Keep voting power (delegation + multipliers) above proposalThreshold while proposal is active, or it may be canceled by anyone"
+          },
+          cancelability: null
+        };
+        let subdaoAddr = subdaoAddress ? getAddress(subdaoAddress) : null;
+        let governorAddr = governorAddress ? normaliseGovernor(governorAddress) : null;
+        let timelockAddr = null;
+        let opsSafe = null;
+        if (subdaoAddr) {
           try {
-            const i3 = new Interface(["function stakeAmount() view returns (uint256)"]);
-            const r3 = await provider.call({ to: govAddr, data: i3.encodeFunctionData("stakeAmount", []) });
-            if (r3 && r3 !== "0x") stakeRequired = BigInt(AbiCoder.defaultAbiCoder().decode(["uint256"], r3)[0].toString());
-          } catch (_2) {
+            const info = await subdao.getSubDAOInfo({ provider, subdao: subdaoAddr });
+            governorAddr = governorAddr || info.governor;
+            timelockAddr = info.timelock || timelockAddr;
+            opsSafe = info.treasury || null;
+          } catch (err) {
+            push({
+              item: "Resolve SubDAO context",
+              met: false,
+              severity: "warn",
+              evidence: { subdao: subdaoAddr, error: String(err?.message || err) }
+            });
           }
         }
-        let allowanceOk = null;
-        let sxxx = null;
+        if (!governorAddr) {
+          throw new SageSDKError(CODES.INVALID_ARGS, "could not resolve governor address");
+        }
+        let govInfo = null;
         try {
-          const i4 = new Interface(["function sxxxToken() view returns (address)"]);
-          const r4 = await provider.call({ to: govAddr, data: i4.encodeFunctionData("sxxxToken", []) });
-          const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], r4);
-          sxxx = getAddress(addr);
+          govInfo = await getGovernorInfo({ provider, governor: governorAddr });
+          timelockAddr = timelockAddr || govInfo.timelock || null;
         } catch (_) {
         }
-        if (sxxx && stakeRequired != null) {
+        let governanceProfile = { kind: null, proposalAccess: null, executionAccess: null, profileInitialized: false };
+        if (subdaoAddr) {
           try {
-            const i5 = new Interface(["function allowance(address,address) view returns (uint256)"]);
-            const r5 = await provider.call({ to: sxxx, data: i5.encodeFunctionData("allowance", [user, govAddr]) });
-            const [allow] = AbiCoder.defaultAbiCoder().decode(["uint256"], r5);
-            allowanceOk = BigInt(allow.toString()) >= BigInt(stakeRequired);
+            const prof = await subdao.getGovernanceProfile({ provider, subdao: subdaoAddr });
+            governanceProfile = {
+              kind: prof.kind,
+              proposalAccess: prof.proposalAccess,
+              executionAccess: prof.executionAccess,
+              profileInitialized: !!prof.profileInitialized
+            };
           } catch (_) {
           }
         }
-        let votesOk = null;
+        let votesChain = null;
         try {
-          const { votingToken } = await resolveVotesTokenChain({ provider, governor });
-          const votes = await getVotesLatestMinusOne({ provider, token: votingToken, account: user });
-          const th = threshold != null ? BigInt(threshold) : 0n;
-          votesOk = votes >= th;
+          votesChain = await resolveVotesTokenChain({ provider, subdao: subdaoAddr || void 0, governor: governorAddr });
         } catch (_) {
+          votesChain = null;
+        }
+        if (proposalId != null) {
+          try {
+            proposal.cancelability = await getProposalCancelability({ provider, governor: governorAddr, proposalId });
+          } catch (_) {
+            proposal.cancelability = null;
+          }
+        }
+        let timelockInfo = {
+          proposerRole: null,
+          executorRole: null,
+          governorIsProposer: null,
+          governorIsExecutor: null,
+          governorCanExecute: null,
+          anyoneCanExecute: null,
+          accountIsProposer: null,
+          accountIsExecutor: null
+        };
+        if (timelockAddr) {
+          try {
+            const tl = new Contract(timelockAddr, ABI.Timelock, provider);
+            const [PR, ER] = await Promise.all([
+              tl.PROPOSER_ROLE().catch(() => null),
+              tl.EXECUTOR_ROLE().catch(() => null)
+            ]);
+            timelockInfo.proposerRole = PR;
+            timelockInfo.executorRole = ER;
+            if (PR && governorAddr) {
+              timelockInfo.governorIsProposer = await tl.hasRole(PR, governorAddr).catch(() => null);
+            }
+            if (ER && governorAddr) {
+              timelockInfo.governorIsExecutor = await tl.hasRole(ER, governorAddr).catch(() => null);
+            }
+            if (ER) {
+              timelockInfo.anyoneCanExecute = await tl.hasRole(ER, ZeroAddress).catch(() => null);
+            }
+            timelockInfo.governorCanExecute = timelockInfo.anyoneCanExecute === true || timelockInfo.governorIsExecutor === true;
+            if (acct && PR) {
+              timelockInfo.accountIsProposer = await tl.hasRole(PR, acct).catch(() => null);
+            }
+            if (acct && ER) {
+              timelockInfo.accountIsExecutor = await tl.hasRole(ER, acct).catch(() => null);
+            }
+          } catch (_) {
+          }
+        }
+        const governorCanQueue = timelockInfo.governorIsProposer === true;
+        const governorCanExecute = timelockInfo.governorCanExecute === true;
+        const authority = { route: "unknown", rationale: "insufficient context", requiredActor: "unknown" };
+        const requireCouncil = governanceProfile.proposalAccess === "COUNCIL_ONLY";
+        const requireTokenThreshold = governanceProfile.proposalAccess === "COMMUNITY_THRESHOLD";
+        const execIsAnyone = governanceProfile.executionAccess === "ANYONE";
+        const execIsCouncilOnly = governanceProfile.executionAccess === "COUNCIL_ONLY";
+        const safeOrCouncil = opsSafe ? `opsSafe ${opsSafe}` : "council/safe";
+        if (actionNorm === "timelock-schedule") {
+          authority.route = "timelock-schedule";
+          authority.rationale = "Direct timelock scheduling/execution path (operator/council governance)";
+          authority.requiredActor = `Timelock PROPOSER_ROLE holder (often ${safeOrCouncil})`;
+        } else if (actionNorm === "update-library") {
+          if (governorCanQueue && governanceProfile.kind === "TOKEN") {
+            authority.route = "governor-propose";
+            authority.rationale = "LibraryRegistry updates are executed by the DAO timelock; token DAOs route via Governor \u2192 Timelock";
+            authority.requiredActor = requireCouncil ? `COUNCIL_ROLE (${safeOrCouncil})` : "Proposer meeting proposalThreshold";
+          } else {
+            authority.route = "timelock-schedule";
+            authority.rationale = "LibraryRegistry updates are executed by the DAO timelock; operator/council DAOs schedule directly on Timelock";
+            authority.requiredActor = `Timelock PROPOSER_ROLE holder (often ${safeOrCouncil})`;
+          }
+        } else if (actionNorm === "propose") {
+          if (!governorCanQueue && timelockAddr) {
+            authority.route = "timelock-schedule";
+            authority.rationale = "Governor is not a Timelock proposer; governance changes must be scheduled directly on Timelock (operator/council mode)";
+            authority.requiredActor = `Timelock PROPOSER_ROLE holder (often ${safeOrCouncil})`;
+          } else {
+            authority.route = "governor-propose";
+            authority.rationale = "Standard token-governance proposal flow (Governor \u2192 Timelock)";
+            authority.requiredActor = requireCouncil ? `COUNCIL_ROLE (${safeOrCouncil})` : requireTokenThreshold ? "Proposer meeting proposalThreshold" : "Proposer meeting proposalThreshold";
+          }
+        } else if (actionNorm === "vote") {
+          if (governanceProfile.kind === "OPERATOR") {
+            authority.route = "not-applicable";
+            authority.rationale = "Operator governance: token voting is not required for changes";
+            authority.requiredActor = `Operator/council (${safeOrCouncil})`;
+          } else {
+            authority.route = "governor-vote";
+            authority.rationale = "Token governance voting on Governor proposals";
+            authority.requiredActor = "Voter with delegated voting power";
+          }
+        } else if (actionNorm === "queue") {
+          if (governorCanQueue) {
+            authority.route = "governor-queue";
+            authority.rationale = "Queue via GovernorTimelockControl (Governor schedules on Timelock)";
+            authority.requiredActor = "Any account (Governor performs the Timelock schedule as proposer)";
+          } else {
+            authority.route = "timelock-schedule";
+            authority.rationale = "Queue by scheduling directly on Timelock (operator/council mode)";
+            authority.requiredActor = `Timelock PROPOSER_ROLE holder (often ${safeOrCouncil})`;
+          }
+        } else if (actionNorm === "execute") {
+          if (governorCanQueue && governorCanExecute) {
+            authority.route = "governor-execute";
+            authority.rationale = "Execute via GovernorTimelockControl (Timelock.execute called by Governor)";
+            authority.requiredActor = "Any account (Governor performs the Timelock execute)";
+          } else {
+            authority.route = "timelock-execute";
+            authority.rationale = "Execute by calling Timelock.execute directly (restricted executor or operator/council mode)";
+            authority.requiredActor = execIsCouncilOnly ? `Timelock EXECUTOR_ROLE holder (${safeOrCouncil})` : `Timelock EXECUTOR_ROLE holder (often ${safeOrCouncil})`;
+          }
+        }
+        if (!acct) {
+          push({
+            item: "Account provided for readiness checks",
+            met: false,
+            severity: "info",
+            evidence: { note: "Pass account to enable per-user readiness checks" }
+          });
+        } else {
+          if ((actionNorm === "propose" || actionNorm === "vote") && votesChain && votesChain.votingToken) {
+            try {
+              const res = await getVotesLatestMinusOneWithTimepoint({ provider, token: votesChain.votingToken, account: acct });
+              proposal.proposerVotes = res.votes;
+              proposal.votesTimepoint = res.timepoint;
+            } catch (_) {
+            }
+          }
+          if (actionNorm === "propose" || actionNorm === "vote") {
+            let voting = null;
+            try {
+              voting = await getVotingStatus({ provider, subdao: subdaoAddr || void 0, governor: governorAddr, account: acct });
+            } catch (_) {
+              voting = null;
+            }
+            if (!voting || !voting.baseToken) {
+              push({ item: "Resolve voting token wiring", met: false, severity: "warn" });
+            } else {
+              const threshold = voting.threshold != null ? BigInt(voting.threshold) : null;
+              const votingPower = voting.votingPower != null ? BigInt(voting.votingPower) : null;
+              let baseBalance = null;
+              let baseDelegate = null;
+              try {
+                const base = new Contract(voting.baseToken, ABI.ERC20Votes, provider);
+                const [bal, del] = await Promise.all([
+                  base.balanceOf(acct).catch(() => null),
+                  base.delegates(acct).catch(() => null)
+                ]);
+                if (bal != null) baseBalance = BigInt(bal.toString());
+                if (del && /^0x[0-9a-fA-F]{40}$/.test(String(del))) baseDelegate = getAddress(del);
+              } catch (_) {
+              }
+              const hasVotes = votingPower != null ? votingPower > 0n : null;
+              push({
+                item: "Voting power is non-zero (delegated)",
+                met: hasVotes,
+                severity: hasVotes === false ? "error" : "info",
+                evidence: {
+                  votingPower: votingPower?.toString?.() ?? null,
+                  votingToken: voting.votingToken,
+                  baseToken: voting.baseToken,
+                  note: threshold != null ? `proposalThreshold=${threshold.toString()}` : void 0
+                }
+              });
+              const noDelegateSet = !baseDelegate || baseDelegate === ZeroAddress;
+              if ((actionNorm === "propose" || actionNorm === "vote") && baseBalance != null && baseBalance > 0n && (votingPower === 0n || votingPower === null) && noDelegateSet) {
+                try {
+                  const payload = buildDelegateTx({ token: voting.baseToken, delegatee: acct });
+                  push({
+                    item: "Delegation set (ERC20Votes)",
+                    met: false,
+                    severity: "error",
+                    evidence: { baseToken: voting.baseToken, delegate: baseDelegate || ZeroAddress, baseBalance: baseBalance.toString() },
+                    fix: { kind: "tx", commandOrCalldata: payload }
+                  });
+                } catch (_) {
+                  push({
+                    item: "Delegation set (ERC20Votes)",
+                    met: false,
+                    severity: "error",
+                    evidence: { baseToken: voting.baseToken, delegate: baseDelegate || ZeroAddress, baseBalance: baseBalance?.toString?.() ?? null }
+                  });
+                }
+              }
+            }
+          }
+          if (actionNorm === "propose" && authority.route === "governor-propose") {
+            let thresholdStatus = null;
+            try {
+              thresholdStatus = await getProposalThresholdStatus({ provider, governor: governorAddr, proposer: acct });
+            } catch (_) {
+            }
+            if (thresholdStatus) {
+              const {
+                proposalThreshold,
+                proposerVotes,
+                votesTimepoint,
+                sxxxBalance,
+                thresholdMet,
+                cooldownRemaining,
+                cooldownElapsed,
+                sxxxToken
+              } = thresholdStatus;
+              proposal.proposalThreshold = proposalThreshold;
+              proposal.sxxxToken = sxxxToken;
+              proposal.proposerSxxxBalance = sxxxBalance;
+              proposal.proposerVotes = proposerVotes;
+              proposal.votesTimepoint = votesTimepoint;
+              proposal.thresholdMet = thresholdMet;
+              proposal.cooldownRemaining = cooldownRemaining;
+              proposal.cooldownElapsed = cooldownElapsed;
+              proposal.cancelPolicy.enabled = proposalThreshold != null ? proposalThreshold > 0n : null;
+              if (proposalThreshold != null) {
+                push({
+                  item: "Voting power meets proposalThreshold (clock()-1)",
+                  met: thresholdMet,
+                  severity: thresholdMet === false ? "error" : "info",
+                  evidence: {
+                    proposerVotes: proposerVotes?.toString?.() ?? null,
+                    votesTimepoint: votesTimepoint?.toString?.() ?? null,
+                    proposalThreshold: proposalThreshold.toString(),
+                    sxxxToken,
+                    note: "No approve/escrow needed - delegate and keep sufficient voting power"
+                  }
+                });
+              }
+              if (cooldownRemaining != null) {
+                push({
+                  item: "Proposal cooldown elapsed",
+                  met: cooldownElapsed,
+                  severity: cooldownElapsed === false ? "warn" : "info",
+                  evidence: { cooldownRemainingSeconds: cooldownRemaining.toString() }
+                });
+              }
+              if (proposalThreshold != null && proposalThreshold > 0n) {
+                push({
+                  item: "Note: Proposal cancelability",
+                  met: true,
+                  severity: "info",
+                  evidence: {
+                    note: "Keep voting power (delegation + multipliers) above threshold while proposal is active, or it may be canceled by anyone",
+                    proposalThreshold: proposalThreshold.toString()
+                  }
+                });
+              }
+            }
+          }
+          if (actionNorm === "timelock-schedule" || authority.route === "timelock-schedule") {
+            if (!timelockAddr) {
+              push({ item: "Timelock resolved", met: false, severity: "error" });
+            } else if (timelockInfo.proposerRole) {
+              push({
+                item: "Account has Timelock PROPOSER_ROLE",
+                met: timelockInfo.accountIsProposer,
+                severity: timelockInfo.accountIsProposer === false ? "error" : "info",
+                evidence: { timelock: timelockAddr, account: acct }
+              });
+            }
+          }
+          if ((actionNorm === "queue" || actionNorm === "execute") && proposalId != null) {
+            try {
+              const g = new Contract(governorAddr, ABI.Governor, provider);
+              const pid = typeof proposalId === "bigint" ? proposalId : String(proposalId).startsWith("0x") ? BigInt(String(proposalId)) : BigInt(String(proposalId));
+              const st = await g.state(pid).catch(() => null);
+              if (st != null) {
+                push({
+                  item: "Proposal state readable",
+                  met: true,
+                  severity: "info",
+                  evidence: { proposalId: pid.toString(), state: Number(st) }
+                });
+              }
+            } catch (_) {
+            }
+          }
+          if (actionNorm === "update-library") {
+            const regAddr = libraryRegistry || process.env.LIBRARY_REGISTRY_ADDRESS || process.env.SAGE_LIBRARY_REGISTRY_ADDRESS || null;
+            const daoAddr = dao ? getAddress(dao) : subdaoAddr || null;
+            if (!regAddr) {
+              push({ item: "LibraryRegistry address provided", met: false, severity: "error" });
+            } else if (!daoAddr) {
+              push({ item: "DAO/SubDAO address provided", met: false, severity: "error" });
+            } else if (!timelockAddr) {
+              push({ item: "Timelock resolved for DAO", met: false, severity: "error" });
+            } else {
+              try {
+                const reg = new Contract(getAddress(regAddr), ABI.LibraryRegistry, provider);
+                const daoTl = await reg.daoTimelock(daoAddr).catch(() => null);
+                const daoTimelock = daoTl && /^0x[0-9a-fA-F]{40}$/.test(String(daoTl)) ? getAddress(daoTl) : null;
+                const match = daoTimelock ? daoTimelock.toLowerCase() === timelockAddr.toLowerCase() : null;
+                push({
+                  item: "LibraryRegistry daoTimelock matches resolved Timelock",
+                  met: match,
+                  severity: match === false ? "error" : "info",
+                  evidence: { libraryRegistry: getAddress(regAddr), dao: daoAddr, daoTimelock, timelock: timelockAddr }
+                });
+                if (match === true && manifestCID) {
+                  const library = require_library();
+                  const payload = library.buildUpdateLibraryTx({
+                    registry: getAddress(regAddr),
+                    subdao: daoAddr,
+                    manifestCID: String(manifestCID),
+                    version: String(version || "1.0.0")
+                  });
+                  const sim = await library.simulateAsTimelock({ provider, registry: getAddress(regAddr), to: payload.to, data: payload.data, timelock: timelockAddr });
+                  push({
+                    item: "Simulate LibraryRegistry.updateLibrary as Timelock",
+                    met: !!sim.ok,
+                    severity: sim.ok ? "info" : "error",
+                    evidence: sim.ok ? { ok: true } : { ok: false, error: sim.error?.message || "revert" }
+                  });
+                }
+              } catch (_) {
+              }
+            }
+          }
         }
         return {
-          threshold: threshold != null ? BigInt(threshold) : null,
-          cooldown,
-          // bigint | null
-          stake: stakeRequired,
-          allowanceOk,
-          votesOk,
-          details: { sxxxToken: sxxx, proposer: user, governor: govAddr }
+          governanceProfile,
+          proposal,
+          addresses: {
+            subdao: subdaoAddr,
+            governor: governorAddr,
+            timelock: timelockAddr,
+            opsSafe,
+            votingToken: votesChain ? votesChain.votingToken : null,
+            baseVotingToken: votesChain ? votesChain.baseToken : null
+          },
+          authority,
+          readiness
         };
       },
-      /**
-       * Compose propose readiness with optional execution readiness checks.
-       * execution?: { provider, registry, timelock, subdao, manifestCID, version }
-       */
-      readinessToPropose: async function readinessToPropose({ provider, governor, proposer, execution = null }) {
-        const gates = await this.ensureProposeGates({ provider, governor, proposer });
-        let executionReady = null;
-        let executionError = null;
-        if (execution && execution.registry && execution.timelock && execution.subdao) {
-          try {
-            const library = require_library();
-            const { to, data } = library.buildUpdateLibraryTx({
-              registry: execution.registry,
-              subdao: execution.subdao,
-              manifestCID: execution.manifestCID || "",
-              version: execution.version || "1.0.0"
-            });
-            const sim = await library.simulateAsTimelock({ provider, registry: execution.registry, to, data, timelock: execution.timelock });
-            executionReady = !!sim.ok;
-            executionError = sim.ok ? null : sim.error?.message || "revert";
-          } catch (err) {
-            executionReady = false;
-            executionError = String(err && err.message || err);
-          }
-        }
-        return { ...gates, executionReady, executionError };
-      },
       /** List active proposals (default states: PENDING, ACTIVE) via subgraph. */
       listActiveProposals: async function listActiveProposals({ url, governor, first = 20, skip = 0 }) {
         if (!url) throw new SageSDKError(CODES.INVALID_ARGS, "subgraph url required");
@@ -4301,22 +5421,21 @@ var require_governance = __commonJS({
       /**
        * Detect governance mode and operator status.
        * Heuristics mirror CLI detectGovMode.
-       * Returns { operator: boolean, governance: 'Personal'|'Community'|'Unknown', governor, timelock, subdao, stakeRequired, depositWei }
+       * Returns { operator: boolean, governance: 'Personal'|'Community'|'Unknown', governor, timelock, subdao, depositWei }
        */
-      detectMode: async function detectMode({ provider, governor, timelock, subdao }) {
+      detectMode: async function detectMode({ provider, governor, timelock, subdao: subdao2 }) {
         const out = {
           operator: false,
           governance: "Unknown",
           governor: governor || null,
           timelock: timelock || null,
-          subdao: subdao || null,
-          stakeRequired: null,
+          subdao: subdao2 || null,
           depositWei: null
         };
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
         try {
-          if (subdao && (!governor || !timelock)) {
-            const sub = new Contract(getAddress(subdao), ["function governor() view returns (address)", "function timelock() view returns (address)", "function getGovernanceMode() view returns (uint8)"], provider);
+          if (subdao2 && (!governor || !timelock)) {
+            const sub = new Contract(getAddress(subdao2), ["function governor() view returns (address)", "function timelock() view returns (address)", "function getGovernanceMode() view returns (uint8)"], provider);
             if (!governor) out.governor = await sub.governor();
             if (!timelock) out.timelock = await sub.timelock();
             try {
@@ -4338,313 +5457,61 @@ var require_governance = __commonJS({
         }
         try {
           if (out.governor) {
-            const ifaceStake = new Interface(["function proposalStakeRequired() view returns (uint256)"]);
-            const retStake = await provider.call({ to: getAddress(out.governor), data: ifaceStake.encodeFunctionData("proposalStakeRequired", []) }).catch(() => null);
-            if (retStake && retStake !== "0x") out.stakeRequired = BigInt(retStake);
-            const ifaceDep = new Interface(["function bootstrapDepositWei() view returns (uint256)"]);
-            const retDep = await provider.call({ to: getAddress(out.governor), data: ifaceDep.encodeFunctionData("bootstrapDepositWei", []) }).catch(() => null);
-            if (retDep && retDep !== "0x") out.depositWei = BigInt(retDep);
-          }
-        } catch (_) {
-        }
-        return out;
-      }
-    };
-  }
-});
-
-// src/governance/intents.js
-var require_intents = __commonJS({
-  "src/governance/intents.js"(exports2, module2) {
-    var { Interface, getAddress } = require("ethers");
-    var { SageSDKError, CODES } = require_errors();
-    function normalise(addr, label) {
-      try {
-        return getAddress(addr);
-      } catch {
-        throw new SageSDKError(CODES.INVALID_ARGS, `${label} required/invalid`);
-      }
-    }
-    var GovIface = new Interface([
-      "function updateQuorumNumerator(uint256)",
-      "function setVotingPeriodBlocks(uint32)",
-      "function setDepositOnlyMode(bool)"
-    ]);
-    var RegIface = new Interface([
-      "function setForkPolicy(uint8)",
-      "function updatePromptByGovernance(string,string)",
-      "function addPrompt(string,bytes32[],string,string,uint8)"
-    ]);
-    var CfgIface = new Interface([
-      "function setPremiumRevSplit(address,uint16,uint16,uint16)",
-      "function setCreatorStakeBps(address,uint256)"
-    ]);
-    module2.exports = {
-      // Governor targets
-      buildUpdateQuorumTx: ({ governor, quorumPercent }) => ({ to: normalise(governor, "governor"), data: GovIface.encodeFunctionData("updateQuorumNumerator", [Number(quorumPercent)]), value: 0n }),
-      buildSetVotingPeriodTx: ({ governor, blocks }) => ({ to: normalise(governor, "governor"), data: GovIface.encodeFunctionData("setVotingPeriodBlocks", [Number(blocks)]), value: 0n }),
-      buildSetDepositOnlyTx: ({ governor, enabled }) => ({ to: normalise(governor, "governor"), data: GovIface.encodeFunctionData("setDepositOnlyMode", [!!enabled]), value: 0n }),
-      // Registry targets
-      buildSetForkPolicyTx: ({ registry, policy }) => ({ to: normalise(registry, "registry"), data: RegIface.encodeFunctionData("setForkPolicy", [Number(policy)]), value: 0n }),
-      buildUpdatePromptByGovernanceTx: ({ registry, key, cid }) => ({ to: normalise(registry, "registry"), data: RegIface.encodeFunctionData("updatePromptByGovernance", [String(key), String(cid)]), value: 0n }),
-      buildAddPromptTx: ({ registry, title, tags = [], contentCID, metadataCID = "", category = 0 }) => ({ to: normalise(registry, "registry"), data: RegIface.encodeFunctionData("addPrompt", [String(title), tags, String(contentCID), String(metadataCID), Number(category)]), value: 0n }),
-      // GovernanceConfig targets
-      buildSetPremiumSplitTx: ({ config, subdao, treasuryBps, protocolBps, creatorBps }) => ({ to: normalise(config, "config"), data: CfgIface.encodeFunctionData("setPremiumRevSplit", [normalise(subdao, "subdao"), Number(treasuryBps), Number(protocolBps), Number(creatorBps)]), value: 0n }),
-      buildSetCreatorStakeBpsTx: ({ config, subdao, bps }) => ({ to: normalise(config, "config"), data: CfgIface.encodeFunctionData("setCreatorStakeBps", [normalise(subdao, "subdao"), Number(bps)]), value: 0n })
-    };
-  }
-});
-
-// src/utils/logs.js
-var require_logs = __commonJS({
-  "src/utils/logs.js"(exports2, module2) {
-    async function fetchLogsChunked({ provider, address, topics = [], fromBlock = 0, toBlock = "latest", chunkSize = 5e4 }) {
-      if (!provider) throw new Error("provider required");
-      const latest = toBlock === "latest" ? await provider.getBlockNumber() : Number(toBlock);
-      let start = Number(fromBlock);
-      const logs = [];
-      while (start <= latest) {
-        const end = Math.min(start + chunkSize - 1, latest);
-        const chunk = await provider.getLogs({ address, topics, fromBlock: start, toBlock: end });
-        logs.push(...chunk);
-        start = end + 1;
-      }
-      return logs;
-    }
-    module2.exports = {
-      fetchLogsChunked
-    };
-  }
-});
-
-// src/subdao/index.js
-var require_subdao = __commonJS({
-  "src/subdao/index.js"(exports2, module2) {
-    var { Contract, Interface, getAddress } = require("ethers");
-    var ABI = require_abi();
-    var { fetchLogsChunked } = require_logs();
-    var { SageSDKError, CODES } = require_errors();
-    function normalise(address, label) {
-      if (!address) throw new SageSDKError(CODES.INVALID_ARGS, `${label} required`);
-      try {
-        return getAddress(address);
-      } catch (err) {
-        throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
-      }
-    }
-    async function discoverSubDAOs({ provider, factoryAddress, fromBlock = 0, toBlock = "latest", limit = 5e3, chunkSize = 5e4 }) {
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const fac = normalise(factoryAddress, "factoryAddress");
-      const iface = new Interface(ABI.Factory);
-      const topic = iface.getEvent("SubDAOGovernanceDeployed").topicHash;
-      const logs = await fetchLogsChunked({ provider, address: fac, topics: [topic], fromBlock, toBlock, chunkSize });
-      const out = [];
-      const slice = limit > 0 ? logs.slice(-limit) : logs;
-      for (const log of slice) {
-        try {
-          const decoded = iface.decodeEventLog("SubDAOGovernanceDeployed", log.data, log.topics);
-          out.push({
-            subdao: getAddress(decoded[0]),
-            governor: getAddress(decoded[1]),
-            timelock: getAddress(decoded[2]),
-            treasury: decoded[3] ? getAddress(decoded[3]) : null,
-            txHash: log.transactionHash,
-            blockNumber: log.blockNumber
-          });
-        } catch (err) {
-          continue;
-        }
-      }
-      return out;
-    }
-    async function getSubDAOInfo({ provider, subdao }) {
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(subdao, "subdao");
-      const contract = new Contract(addr, ABI.SubDAO, provider);
-      const [governor, timelock, mode, promptRegistry, sageTreasury, stakeToken, minStakeAmount, accessModel, membershipPolicy, profileCID, factoryDeployer] = await Promise.all([
-        contract.governor(),
-        contract.timelock(),
-        contract.getGovernanceMode().catch(() => null),
-        contract.promptRegistry().catch(() => null),
-        contract.sageTreasury().catch(() => null),
-        contract.stakeToken().catch(() => null),
-        contract.minStakeAmount().catch(() => null),
-        contract.accessModel().catch(() => null),
-        contract.membershipPolicy().catch(() => null),
-        contract.profileCID().catch(() => null),
-        contract.factoryDeployer().catch(() => null)
-      ]);
-      return {
-        address: addr,
-        governor: getAddress(governor),
-        timelock: getAddress(timelock),
-        governanceMode: mode,
-        promptRegistry: promptRegistry ? getAddress(promptRegistry) : null,
-        sageTreasury: sageTreasury ? getAddress(sageTreasury) : null,
-        stakeToken: stakeToken && stakeToken !== "0x0000000000000000000000000000000000000000" ? getAddress(stakeToken) : null,
-        minStakeAmount: minStakeAmount != null ? BigInt(minStakeAmount.toString()) : null,
-        accessModel: accessModel != null ? Number(accessModel) : null,
-        membershipPolicy: membershipPolicy != null ? Number(membershipPolicy) : null,
-        profileCID: profileCID || null,
-        factoryDeployer: factoryDeployer && factoryDeployer !== "0x0000000000000000000000000000000000000000" ? getAddress(factoryDeployer) : null
-      };
-    }
-    async function getSubDAOUserStats({ provider, subdao, account }) {
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const addr = normalise(subdao, "subdao");
-      const user = normalise(account, "account");
-      const contract = new Contract(addr, ABI.SubDAO, provider);
-      const [staked, userForkCount] = await Promise.all([
-        contract.stakedAmount(user).catch(() => 0n),
-        contract.userForkCount(user).catch(() => 0n)
-      ]);
-      return {
-        stakedAmount: BigInt(staked.toString()),
-        userForkCount: Number(userForkCount)
-      };
-    }
-    var SubDAOInterface = new Interface([
-      "function stake(uint256)",
-      "function unstake(uint256)",
-      // Optional on newer SubDAO implementations; provided for tx building only.
-      "function setProfileCid(string)"
-    ]);
-    function buildStakeTx({ subdao, amount }) {
-      const addr = normalise(subdao, "subdao");
-      const data = SubDAOInterface.encodeFunctionData("stake", [BigInt(amount)]);
-      return { to: addr, data, value: 0n };
-    }
-    function buildUnstakeTx({ subdao, amount }) {
-      const addr = normalise(subdao, "subdao");
-      const data = SubDAOInterface.encodeFunctionData("unstake", [BigInt(amount)]);
-      return { to: addr, data, value: 0n };
-    }
-    function buildSetProfileCidTx({ subdao, profileCid }) {
-      const addr = normalise(subdao, "subdao");
-      if (!profileCid || typeof profileCid !== "string" || !profileCid.trim()) {
-        throw new SageSDKError(CODES.INVALID_ARGS, "profileCid (CID string) required");
-      }
-      const data = SubDAOInterface.encodeFunctionData("setProfileCid", [String(profileCid)]);
-      return { to: addr, data, value: 0n };
-    }
-    module2.exports = {
-      discoverSubDAOs,
-      getSubDAOInfo,
-      getSubDAOUserStats,
-      buildStakeTx,
-      buildUnstakeTx,
-      buildSetProfileCidTx
-    };
-    async function ensureSxxxBurnAllowance({ signer, sxxx, owner, spender, amount }) {
-      if (!signer) throw new SageSDKError(CODES.INVALID_ARGS, "signer required");
-      if (!sxxx) throw new SageSDKError(CODES.INVALID_ARGS, "sxxx address required");
-      if (!spender) throw new SageSDKError(CODES.INVALID_ARGS, "spender (factory) required");
-      const sxxxAddr = getAddress(sxxx);
-      const spenderAddr = getAddress(spender);
-      const erc = new Contract(sxxxAddr, ABI.SXXX, signer);
-      const ownerAddr = owner ? getAddress(owner) : await signer.getAddress();
-      const need = BigInt(amount || 0n);
-      if (need === 0n) return { approved: false, tx: null };
-      const current = await erc.allowance(ownerAddr, spenderAddr);
-      const cur = BigInt(current.toString());
-      if (cur >= need) return { approved: false, tx: null };
-      const tx = await erc.approve(spenderAddr, need);
-      const rcpt = await tx.wait();
-      return { approved: true, tx, receipt: rcpt };
-    }
-    async function createSubDAO({ signer, factoryAddress, name, description, accessModel, minStakeAmount, burnAmount, sxxx }) {
-      if (!signer) throw new SageSDKError(CODES.INVALID_ARGS, "signer required");
-      if (!factoryAddress) throw new SageSDKError(CODES.INVALID_ARGS, "factoryAddress required");
-      const provider = signer.provider;
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "signer.provider required");
-      if (sxxx && BigInt(burnAmount || 0n) > 0n) {
-        await ensureSxxxBurnAllowance({ signer, sxxx, spender: factoryAddress, amount: BigInt(burnAmount) });
-      }
-      const fac = new Contract(getAddress(factoryAddress), ABI.FactoryWrite, signer);
-      const args = [
-        String(name || ""),
-        String(description || ""),
-        Number(accessModel ?? 0),
-        BigInt(minStakeAmount ?? 0n),
-        BigInt(burnAmount ?? 0n)
-      ];
-      let tx;
-      try {
-        tx = await fac.createSubDAO(...args);
-      } catch (err) {
-        tx = await fac.createSubDAO(...args, { gasLimit: 8e6 });
-      }
-      const receipt = await tx.wait();
-      const iface = new Interface(ABI.Factory);
-      let subdao = null, governor = null, timelock = null, treasury = null, registry = null;
-      for (const log of receipt.logs || []) {
-        try {
-          const parsed = iface.parseLog(log);
-          if (parsed && parsed.name === "SubDAOGovernanceDeployed") {
-            subdao = getAddress(parsed.args.subDAO || parsed.args[0]);
-            governor = getAddress(parsed.args.governor || parsed.args[1]);
-            timelock = getAddress(parsed.args.timelock || parsed.args[2]);
-            treasury = getAddress(parsed.args.treasury || parsed.args[3]);
-          } else if (parsed && parsed.name === "SubDAOCreated") {
-            const maybe = parsed.args.registry || parsed.args[2];
-            if (maybe) registry = getAddress(maybe);
-            if (!subdao) subdao = getAddress(parsed.args.subDAO || parsed.args[0]);
+            const ifaceDep = new Interface(["function bootstrapDepositWei() view returns (uint256)"]);
+            const retDep = await provider.call({ to: getAddress(out.governor), data: ifaceDep.encodeFunctionData("bootstrapDepositWei", []) }).catch(() => null);
+            if (retDep && retDep !== "0x") out.depositWei = BigInt(retDep);
           }
         } catch (_) {
         }
+        return out;
       }
+    };
+  }
+});
+
+// src/governance/intents.js
+var require_intents = __commonJS({
+  "src/governance/intents.js"(exports2, module2) {
+    var { Interface, getAddress } = require("ethers");
+    var { SageSDKError, CODES } = require_errors();
+    function normalise(addr, label) {
       try {
-        if (subdao && !registry) {
-          const sub = new Contract(subdao, ABI.SubDAO, provider);
-          const reg = await sub.promptRegistry().catch(() => null);
-          if (reg && /^0x/.test(String(reg))) registry = getAddress(reg);
-        }
-      } catch (_) {
-      }
-      return { tx, receipt, subdao, governor, timelock, treasury, registry };
-    }
-    async function makeOperator({ signer, subdao, operator, grantAdmin = false }) {
-      if (!signer) throw new SageSDKError(CODES.INVALID_ARGS, "signer required");
-      const provider = signer.provider;
-      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "signer.provider required");
-      const addr = normalise(subdao, "subdao");
-      const sub = new Contract(addr, ABI.SubDAO, provider);
-      const governor = getAddress(await sub.governor());
-      const timelock = getAddress(await sub.timelock());
-      const TL_ABI = [
-        "function PROPOSER_ROLE() view returns (bytes32)",
-        "function EXECUTOR_ROLE() view returns (bytes32)",
-        "function DEFAULT_ADMIN_ROLE() view returns (bytes32)",
-        "function grantRole(bytes32,address)",
-        "function revokeRole(bytes32,address)"
-      ];
-      const tl = new Contract(timelock, TL_ABI, signer);
-      const [PR, ER, AR] = await Promise.all([
-        tl.PROPOSER_ROLE(),
-        tl.EXECUTOR_ROLE(),
-        tl.DEFAULT_ADMIN_ROLE().catch(() => null)
-      ]);
-      const ops = [];
-      ops.push(await tl.grantRole(PR, getAddress(operator)));
-      ops.push(await tl.grantRole(ER, getAddress(operator)));
-      ops.push(await tl.revokeRole(PR, governor));
-      if (grantAdmin && AR) ops.push(await tl.grantRole(AR, getAddress(operator)));
-      const receipts = [];
-      for (const tx of ops) {
-        receipts.push(await tx.wait());
+        return getAddress(addr);
+      } catch {
+        throw new SageSDKError(CODES.INVALID_ARGS, `${label} required/invalid`);
       }
-      return { governor, timelock, operator: getAddress(operator), txs: ops, receipts };
     }
-    async function createOperatorSubDAO({ signer, factoryAddress, operator, name, description, accessModel, minStakeAmount, burnAmount, sxxx, grantAdmin = false }) {
-      const created = await createSubDAO({ signer, factoryAddress, name, description, accessModel, minStakeAmount, burnAmount, sxxx });
-      if (!created.subdao) throw new SageSDKError(CODES.UNKNOWN, "createSubDAO did not emit SubDAO address");
-      const op = await makeOperator({ signer, subdao: created.subdao, operator, grantAdmin });
-      return { ...created, operatorResult: op };
-    }
-    module2.exports.ensureSxxxBurnAllowance = ensureSxxxBurnAllowance;
-    module2.exports.createSubDAO = createSubDAO;
-    module2.exports.makeOperator = makeOperator;
-    module2.exports.createOperatorSubDAO = createOperatorSubDAO;
+    var GovIface = new Interface([
+      "function setQuorumVotes(uint256)",
+      "function setVotingPeriodBlocks(uint32)",
+      "function setDepositOnlyMode(bool)",
+      // Legacy (deprecated)
+      "function updateQuorumNumerator(uint256)"
+    ]);
+    var RegIface = new Interface([
+      "function setForkPolicy(uint8)",
+      "function updatePromptByGovernance(string,string)",
+      "function addPrompt(string,bytes32[],string,string,uint8)"
+    ]);
+    var CfgIface = new Interface([
+      "function setPremiumRevSplit(address,uint16,uint16,uint16)",
+      "function setCreatorStakeBps(address,uint256)"
+    ]);
+    module2.exports = {
+      // Governor targets
+      buildSetQuorumVotesTx: ({ governor, quorumVotes }) => ({ to: normalise(governor, "governor"), data: GovIface.encodeFunctionData("setQuorumVotes", [BigInt(quorumVotes)]), value: 0n }),
+      buildSetVotingPeriodTx: ({ governor, blocks }) => ({ to: normalise(governor, "governor"), data: GovIface.encodeFunctionData("setVotingPeriodBlocks", [Number(blocks)]), value: 0n }),
+      buildSetDepositOnlyTx: ({ governor, enabled }) => ({ to: normalise(governor, "governor"), data: GovIface.encodeFunctionData("setDepositOnlyMode", [!!enabled]), value: 0n }),
+      // Legacy (deprecated) - use buildSetQuorumVotesTx instead
+      buildUpdateQuorumTx: ({ governor, quorumPercent }) => ({ to: normalise(governor, "governor"), data: GovIface.encodeFunctionData("updateQuorumNumerator", [Number(quorumPercent)]), value: 0n }),
+      // Registry targets
+      buildSetForkPolicyTx: ({ registry, policy }) => ({ to: normalise(registry, "registry"), data: RegIface.encodeFunctionData("setForkPolicy", [Number(policy)]), value: 0n }),
+      buildUpdatePromptByGovernanceTx: ({ registry, key, cid }) => ({ to: normalise(registry, "registry"), data: RegIface.encodeFunctionData("updatePromptByGovernance", [String(key), String(cid)]), value: 0n }),
+      buildAddPromptTx: ({ registry, title, tags = [], contentCID, metadataCID = "", category = 0 }) => ({ to: normalise(registry, "registry"), data: RegIface.encodeFunctionData("addPrompt", [String(title), tags, String(contentCID), String(metadataCID), Number(category)]), value: 0n }),
+      // GovernanceConfig targets
+      buildSetPremiumSplitTx: ({ config, subdao, treasuryBps, protocolBps, creatorBps }) => ({ to: normalise(config, "config"), data: CfgIface.encodeFunctionData("setPremiumRevSplit", [normalise(subdao, "subdao"), Number(treasuryBps), Number(protocolBps), Number(creatorBps)]), value: 0n }),
+      buildSetCreatorStakeBpsTx: ({ config, subdao, bps }) => ({ to: normalise(config, "config"), data: CfgIface.encodeFunctionData("setCreatorStakeBps", [normalise(subdao, "subdao"), Number(bps)]), value: 0n })
+    };
   }
 });
 
@@ -4690,7 +5557,6 @@ var require_templates = __commonJS({
       signer,
       subdao: subdaoAddr,
       operator,
-      stakeAmount,
       cooldownSeconds,
       depositOnly = true
     }) {
@@ -4708,10 +5574,6 @@ var require_templates = __commonJS({
       const operatorHasExecutor = await tl.hasRole(executorRole, operatorAddress).catch(() => false);
       if (!operatorHasExecutor) actions.push(() => tl.grantRole(executorRole, operatorAddress));
       const governorContract = new Contract(governor, abi.Governor, signer);
-      if (stakeAmount != null) {
-        const value = BigInt(stakeAmount);
-        actions.push(() => governorContract.setProposalStakeRequired(value));
-      }
       if (cooldownSeconds != null) {
         const value = BigInt(cooldownSeconds);
         actions.push(() => governorContract.setProposalCooldown(value));
@@ -4726,7 +5588,6 @@ var require_templates = __commonJS({
       provider,
       signer,
       subdao: subdaoAddr,
-      stakeAmount,
       cooldownSeconds,
       anyoneExec = true,
       depositOnly = false
@@ -4746,10 +5607,6 @@ var require_templates = __commonJS({
         if (!hasZeroExec) actions.push(() => tl.grantRole(executorRole, ZeroAddress));
       }
       const governorContract = new Contract(governor, abi.Governor, signer);
-      if (stakeAmount != null) {
-        const value = BigInt(stakeAmount);
-        actions.push(() => governorContract.setProposalStakeRequired(value));
-      }
       if (cooldownSeconds != null) {
         const value = BigInt(cooldownSeconds);
         actions.push(() => governorContract.setProposalCooldown(value));
@@ -5354,8 +6211,7 @@ var require_operations = __commonJS({
       signer,
       governor,
       timelock = null,
-      subdao = null,
-      sxxxToken = null
+      subdao = null
     }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       if (!governor) throw new SageSDKError(CODES.INVALID_ARGS, "governor required");
@@ -5382,29 +6238,11 @@ var require_operations = __commonJS({
       let mode = null;
       let eligible = null;
       if (resolvedSubDAO) {
-        const subdaoContract = new Contract(resolvedSubDAO, ["function getGovernanceMode() view returns (uint8)", "function isEligibleMember(address) view returns (bool)", "function stakeToken() view returns (address)"], provider);
+        const subdaoContract = new Contract(resolvedSubDAO, ["function getGovernanceMode() view returns (uint8)", "function isEligibleMember(address) view returns (bool)"], provider);
         mode = await subdaoContract.getGovernanceMode().catch(() => null);
         if (mode === 0 && signerAddr) {
           eligible = await subdaoContract.isEligibleMember(signerAddr).catch(() => null);
         }
-        if (!sxxxToken) {
-          sxxxToken = await subdaoContract.stakeToken().catch(() => null);
-          if (sxxxToken === ZeroAddress) sxxxToken = null;
-        }
-      }
-      if (!sxxxToken) {
-        sxxxToken = await governorContract.sxxxToken().catch(() => null);
-        if (sxxxToken === ZeroAddress) sxxxToken = null;
-      }
-      let balance = null;
-      let allowance = null;
-      let authorizedBurner = null;
-      const stakeRequired = sxxxToken ? BigInt(50) * BigInt(10) ** BigInt(18) : null;
-      if (sxxxToken && signerAddr) {
-        const tokenContract = new Contract(sxxxToken, ["function balanceOf(address) view returns (uint256)", "function allowance(address,address) view returns (uint256)", "function authorizedBurners(address) view returns (bool)"], provider);
-        balance = await tokenContract.balanceOf(signerAddr).catch(() => null);
-        allowance = await tokenContract.allowance(signerAddr, govAddr).catch(() => null);
-        authorizedBurner = await tokenContract.authorizedBurners(govAddr).catch(() => null);
       }
       let cooldownSeconds = null;
       let cooldownRemaining = null;
@@ -5434,13 +6272,6 @@ var require_operations = __commonJS({
         subdao: resolvedSubDAO,
         governanceMode: mode,
         eligibleMember: eligible,
-        stake: {
-          token: sxxxToken,
-          requiredWei: stakeRequired,
-          balanceWei: balance,
-          allowanceWei: allowance,
-          governorAuthorizedBurner: authorizedBurner
-        },
         timelock
       };
     }
@@ -5875,13 +6706,16 @@ var require_factory = __commonJS({
           accessModel: Number(template[2]),
           forkPolicy: Number(template[3]),
           membershipPolicy: Number(template[4]),
-          minStakeAmount: BigInt(template[5].toString()),
+          // template[5] was minStakeAmount (deprecated)
           burnAmount: BigInt(template[6].toString()),
           votingDelay: BigInt(template[7].toString()),
           votingPeriod: BigInt(template[8].toString()),
           proposalThreshold: BigInt(template[9].toString()),
+          // template[10] is quorumVotes (absolute token amount, e.g., 100e18 = 100 SXXX)
+          quorumVotes: BigInt(template[10].toString()),
           quorumPercentage: Number(template[10]),
-          proposalStakeRequired: BigInt(template[11].toString()),
+          // deprecated alias
+          // template[11] was proposalStakeRequired (deprecated)
           proposalCooldownSeconds: BigInt(template[12].toString()),
           isActive: Boolean(template[13])
         });
@@ -5902,13 +6736,16 @@ var require_factory = __commonJS({
         accessModel: Number(template[2]),
         forkPolicy: Number(template[3]),
         membershipPolicy: Number(template[4]),
-        minStakeAmount: BigInt(template[5].toString()),
+        // template[5] was minStakeAmount (deprecated)
         burnAmount: BigInt(template[6].toString()),
         votingDelay: BigInt(template[7].toString()),
         votingPeriod: BigInt(template[8].toString()),
         proposalThreshold: BigInt(template[9].toString()),
+        // template[10] is quorumVotes (absolute token amount, e.g., 100e18 = 100 SXXX)
+        quorumVotes: BigInt(template[10].toString()),
         quorumPercentage: Number(template[10]),
-        proposalStakeRequired: BigInt(template[11].toString()),
+        // deprecated alias
+        // template[11] was proposalStakeRequired (deprecated)
         proposalCooldownSeconds: BigInt(template[12].toString()),
         isActive: Boolean(template[13]),
         usage: usage != null ? BigInt(usage.toString()) : null,
@@ -5916,18 +6753,19 @@ var require_factory = __commonJS({
       };
     }
     var FactoryWriteInterface = new Interface(ABI.FactoryWrite);
-    function buildCreateSubDAOTx({ factory, name, description, accessModel, minStakeAmount, burnAmount }) {
+    function buildCreateSubDAOTx({ factory, name, description, accessModel, burnAmount }) {
       const addr = normalise(factory, "factory");
       const payload = FactoryWriteInterface.encodeFunctionData("createSubDAO", [
         String(name),
         String(description),
         Number(accessModel),
-        BigInt(minStakeAmount),
+        0n,
+        // minStakeAmount deprecated
         BigInt(burnAmount)
       ]);
       return { to: addr, data: payload, value: 0n };
     }
-    function buildCreateSubDAOWithStableTx({ factory, name, description, accessModel, minStakeAmount, permit }) {
+    function buildCreateSubDAOWithStableTx({ factory, name, description, accessModel, permit }) {
       const addr = normalise(factory, "factory");
       if (!permit) throw new SageSDKError(CODES.INVALID_ARGS, "permit required for stable creation");
       const tuple = [
@@ -5941,7 +6779,8 @@ var require_factory = __commonJS({
         String(name),
         String(description),
         Number(accessModel),
-        BigInt(minStakeAmount),
+        0n,
+        // minStakeAmount deprecated
         tuple
       ]);
       return { to: addr, data: payload, value: 0n };
@@ -5983,30 +6822,37 @@ var require_factory = __commonJS({
       name,
       description,
       accessModel,
-      minStakeAmount,
       burnAmount,
       votingDelay,
       votingPeriod,
       proposalThreshold,
+      quorumVotes,
       quorumPercentage,
+      // deprecated alias for quorumVotes
       initialForkPolicy,
       initialMembershipPolicy,
-      profileCID
+      profileCID,
+      manifestCID,
+      manifestVersion
     }) {
       const addr = normalise(factory, "factory");
+      const quorum = quorumVotes ?? quorumPercentage;
       const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOWithParams", [
         String(name),
         String(description),
         Number(accessModel),
-        BigInt(minStakeAmount),
+        0n,
+        // minStakeAmount deprecated
         BigInt(burnAmount),
         BigInt(votingDelay),
         BigInt(votingPeriod),
         BigInt(proposalThreshold),
-        BigInt(quorumPercentage),
+        BigInt(quorum),
         Number(initialForkPolicy),
         Number(initialMembershipPolicy),
-        String(profileCID ?? "")
+        String(profileCID ?? ""),
+        String(manifestCID ?? ""),
+        String(manifestVersion ?? "")
       ]);
       return { to: addr, data: payload, value: 0n };
     }
@@ -6015,7 +6861,6 @@ var require_factory = __commonJS({
       name,
       description,
       accessModel,
-      minStakeAmount,
       operatorExecutor,
       operatorAdmin,
       permit
@@ -6033,7 +6878,8 @@ var require_factory = __commonJS({
         String(name),
         String(description),
         Number(accessModel),
-        BigInt(minStakeAmount),
+        0n,
+        // minStakeAmount deprecated
         normalise(operatorExecutor, "operatorExecutor"),
         normalise(operatorAdmin, "operatorAdmin"),
         tuple
@@ -6045,7 +6891,6 @@ var require_factory = __commonJS({
       name,
       description,
       accessModel,
-      minStakeAmount,
       operatorExecutor,
       operatorAdmin,
       anyoneExec = false,
@@ -6065,7 +6910,8 @@ var require_factory = __commonJS({
         String(name),
         String(description),
         Number(accessModel),
-        BigInt(minStakeAmount),
+        0n,
+        // minStakeAmount deprecated
         normalise(operatorExecutor, "operatorExecutor"),
         normalise(operatorAdmin, "operatorAdmin"),
         Boolean(anyoneExec),
@@ -7001,7 +7847,7 @@ var require_ipns = __commonJS({
         }
         const worker = workerConfig ? {
           baseUrl: removeTrailingSlash(workerConfig.baseUrl || workerConfig.url || workerConfig.workerBaseUrl || ""),
-          challengePath: ensureLeadingSlash(workerConfig.challengePath || workerConfig.challenge || "/auth/challenge"),
+          challengePath: ensureLeadingSlash(workerConfig.challengePath || workerConfig.challenge || "/ipfs/auth/challenge"),
           publishPath: ensureLeadingSlash(workerConfig.publishPath || workerConfig.publish || "/ipns/publish"),
           token: workerConfig.token || null,
           getAuth: workerConfig.getAuth || null,
@@ -7433,51 +8279,345 @@ var require_access = __commonJS({
       if (!response || !response.decryptedData) {
         throw new Error("[personal] Lit decryption failed: missing decryptedData");
       }
-      return uint8arrayToString(response.decryptedData, "utf8");
+      return uint8arrayToString(response.decryptedData, "utf8");
+    }
+    module2.exports = {
+      resolveEncryptedResource,
+      decryptWithLit
+    };
+  }
+});
+
+// src/personal/index.js
+var require_personal = __commonJS({
+  "src/personal/index.js"(exports2, module2) {
+    var { Interface } = require("ethers");
+    var ABI = require_abi();
+    var { normaliseAddress, toBytes32Key } = require_helpers();
+    function buildCreatePersonalRegistryTx({ factory, policy }) {
+      const to = normaliseAddress(factory, "factory");
+      const iface = new Interface(ABI.PersonalLibraryFacet);
+      const data = iface.encodeFunctionData("createPersonalRegistry", [policy >>> 0]);
+      return { to, data, value: 0n };
+    }
+    function buildSetPriceTx({ marketplace, key, price }) {
+      const to = normaliseAddress(marketplace, "marketplace");
+      const k = toBytes32Key(key);
+      const iface = new Interface(ABI.PersonalMarketplace);
+      const data = iface.encodeFunctionData("setPrice", [k, BigInt(price)]);
+      return { to, data, value: 0n };
+    }
+    function buildBuyTx({ marketplace, creator, key, expectedPrice, deadline }) {
+      const to = normaliseAddress(marketplace, "marketplace");
+      const iface = new Interface(ABI.PersonalMarketplace);
+      const data = iface.encodeFunctionData("purchase", [
+        normaliseAddress(creator, "creator"),
+        toBytes32Key(key),
+        BigInt(expectedPrice),
+        BigInt(deadline)
+      ]);
+      return { to, data, value: 0n };
+    }
+    module2.exports = {
+      buildCreatePersonalRegistryTx,
+      buildSetPriceTx,
+      buildBuyTx,
+      ...require_receipt(),
+      ...require_access()
+    };
+  }
+});
+
+// src/premium/index.js
+var require_premium = __commonJS({
+  "src/premium/index.js"(exports2, module2) {
+    var axios = require("axios");
+    var { getAddress } = require("ethers");
+    function safeGetAddress(value) {
+      try {
+        return getAddress(value);
+      } catch {
+        return null;
+      }
+    }
+    function mapSafe(list, mapper) {
+      const out = [];
+      for (const item of list || []) {
+        try {
+          const v = mapper(item);
+          if (v != null) out.push(v);
+        } catch {
+        }
+      }
+      return out;
+    }
+    async function query(url, document, variables) {
+      if (!url) throw new Error("subgraph url required");
+      const resp = await axios.post(url, { query: document, variables }, { timeout: 1e4 });
+      if (resp.data && resp.data.errors) {
+        throw new Error(resp.data.errors.map((e) => e.message).join("; "));
+      }
+      return resp.data.data;
+    }
+    async function listPremiumPrompts({ url, subdao = null, first = 50, skip = 0, orderBy = "blockTimestamp", orderDirection = "desc" }) {
+      const safeOrderBy = ["blockTimestamp", "price"].includes(orderBy) ? orderBy : "blockTimestamp";
+      const safeOrderDirection = orderDirection === "asc" ? "asc" : "desc";
+      let doc;
+      const variables = {
+        first: Math.min(Math.max(1, Number(first || 50)), 200),
+        skip: Number(skip || 0)
+      };
+      if (subdao) {
+        const addr = safeGetAddress(subdao);
+        if (!addr) throw new Error("invalid subdao address");
+        variables.subdao = addr.toLowerCase();
+        doc = `
+      query($subdao: Bytes!, $first: Int!, $skip: Int!) {
+        premiumPrompts(
+          where: { subdao: $subdao }
+          first: $first
+          skip: $skip
+          orderBy: ${safeOrderBy}
+          orderDirection: ${safeOrderDirection}
+        ) {
+          id
+          cidHash
+          subdao
+          price
+          manifestCID
+          blockNumber
+          blockTimestamp
+          transactionHash
+        }
+      }
+    `;
+      } else {
+        doc = `
+      query($first: Int!, $skip: Int!) {
+        premiumPrompts(
+          first: $first
+          skip: $skip
+          orderBy: ${safeOrderBy}
+          orderDirection: ${safeOrderDirection}
+        ) {
+          id
+          cidHash
+          subdao
+          price
+          manifestCID
+          blockNumber
+          blockTimestamp
+          transactionHash
+        }
+      }
+    `;
+      }
+      const data = await query(url, doc, variables);
+      return mapSafe(data?.premiumPrompts, (p) => {
+        const sub = safeGetAddress(p.subdao);
+        if (!sub) return null;
+        return {
+          id: String(p.id),
+          cidHash: String(p.cidHash),
+          subdao: sub,
+          price: BigInt(String(p.price || "0")),
+          manifestCID: p.manifestCID || null,
+          blockNumber: Number(p.blockNumber || 0),
+          blockTimestamp: Number(p.blockTimestamp || 0),
+          transactionHash: p.transactionHash || null
+        };
+      });
+    }
+    async function getPremiumPrompt({ url, cidHash }) {
+      const id2 = cidHash.toLowerCase().startsWith("0x") ? cidHash.toLowerCase() : `0x${cidHash.toLowerCase()}`;
+      const doc = `
+    query($id: ID!) {
+      premiumPrompt(id: $id) {
+        id
+        cidHash
+        subdao
+        price
+        manifestCID
+        blockNumber
+        blockTimestamp
+        transactionHash
+      }
+      premiumPromptStats(id: $id) {
+        totalRevenue
+        purchaseCount
+        uniqueBuyers
+        currentHolders
+      }
+    }
+  `;
+      const data = await query(url, doc, { id: id2 });
+      const p = data?.premiumPrompt;
+      if (!p) return null;
+      const sub = safeGetAddress(p.subdao);
+      if (!sub) return null;
+      const stats = data?.premiumPromptStats || {};
+      return {
+        id: String(p.id),
+        cidHash: String(p.cidHash),
+        subdao: sub,
+        price: BigInt(String(p.price || "0")),
+        manifestCID: p.manifestCID || null,
+        blockNumber: Number(p.blockNumber || 0),
+        blockTimestamp: Number(p.blockTimestamp || 0),
+        transactionHash: p.transactionHash || null,
+        // Stats
+        totalRevenue: stats.totalRevenue ? BigInt(String(stats.totalRevenue)) : null,
+        purchaseCount: stats.purchaseCount ? BigInt(String(stats.purchaseCount)) : null,
+        uniqueBuyers: stats.uniqueBuyers ? BigInt(String(stats.uniqueBuyers)) : null,
+        currentHolders: stats.currentHolders ? BigInt(String(stats.currentHolders)) : null
+      };
+    }
+    async function listPremiumPurchases({ url, cidHash, first = 50, skip = 0 }) {
+      const normalizedCidHash = cidHash.toLowerCase().startsWith("0x") ? cidHash.toLowerCase() : `0x${cidHash.toLowerCase()}`;
+      const doc = `
+    query($cidHash: Bytes!, $first: Int!, $skip: Int!) {
+      premiumPurchases(
+        where: { cidHash: $cidHash }
+        first: $first
+        skip: $skip
+        orderBy: blockTimestamp
+        orderDirection: desc
+      ) {
+        id
+        cidHash
+        buyer
+        price
+        treasury
+        blockNumber
+        blockTimestamp
+        transactionHash
+      }
+    }
+  `;
+      const data = await query(url, doc, {
+        cidHash: normalizedCidHash,
+        first: Math.min(Math.max(1, Number(first || 50)), 200),
+        skip: Number(skip || 0)
+      });
+      return mapSafe(data?.premiumPurchases, (p) => {
+        const buyer = safeGetAddress(p.buyer);
+        const treasury = safeGetAddress(p.treasury);
+        if (!buyer || !treasury) return null;
+        return {
+          id: String(p.id),
+          cidHash: String(p.cidHash),
+          buyer,
+          price: BigInt(String(p.price || "0")),
+          treasury,
+          blockNumber: Number(p.blockNumber || 0),
+          blockTimestamp: Number(p.blockTimestamp || 0),
+          transactionHash: p.transactionHash || null
+        };
+      });
+    }
+    async function hasPurchased({ url, cidHash, holder }) {
+      const normalizedCidHash = cidHash.toLowerCase().startsWith("0x") ? cidHash.toLowerCase() : `0x${cidHash.toLowerCase()}`;
+      const normalizedHolder = holder.toLowerCase();
+      const id2 = `${normalizedCidHash}-${normalizedHolder}`;
+      const doc = `
+    query($id: ID!) {
+      premiumHolderBalance(id: $id) {
+        balance
+      }
+    }
+  `;
+      const data = await query(url, doc, { id: id2 });
+      const balance = data?.premiumHolderBalance?.balance;
+      return balance ? BigInt(String(balance)) > 0n : false;
+    }
+    async function getHolderBalance({ url, cidHash, holder }) {
+      const normalizedCidHash = cidHash.toLowerCase().startsWith("0x") ? cidHash.toLowerCase() : `0x${cidHash.toLowerCase()}`;
+      const normalizedHolder = holder.toLowerCase();
+      const id2 = `${normalizedCidHash}-${normalizedHolder}`;
+      const doc = `
+    query($id: ID!) {
+      premiumHolderBalance(id: $id) {
+        balance
+        updatedAt
+      }
+    }
+  `;
+      const data = await query(url, doc, { id: id2 });
+      const row = data?.premiumHolderBalance;
+      if (!row) return 0n;
+      return BigInt(String(row.balance || "0"));
+    }
+    async function listHolders({ url, cidHash, first = 100, skip = 0 }) {
+      const normalizedCidHash = cidHash.toLowerCase().startsWith("0x") ? cidHash.toLowerCase() : `0x${cidHash.toLowerCase()}`;
+      const doc = `
+    query($cidHash: Bytes!, $first: Int!, $skip: Int!) {
+      premiumHolderBalances(
+        where: { cidHash: $cidHash, balance_gt: "0" }
+        first: $first
+        skip: $skip
+        orderBy: balance
+        orderDirection: desc
+      ) {
+        id
+        cidHash
+        holder
+        balance
+        updatedAt
+      }
     }
-    module2.exports = {
-      resolveEncryptedResource,
-      decryptWithLit
-    };
-  }
-});
-
-// src/personal/index.js
-var require_personal = __commonJS({
-  "src/personal/index.js"(exports2, module2) {
-    var { Interface } = require("ethers");
-    var ABI = require_abi();
-    var { normaliseAddress, toBytes32Key } = require_helpers();
-    function buildCreatePersonalRegistryTx({ factory, policy }) {
-      const to = normaliseAddress(factory, "factory");
-      const iface = new Interface(ABI.PersonalLibraryFacet);
-      const data = iface.encodeFunctionData("createPersonalRegistry", [policy >>> 0]);
-      return { to, data, value: 0n };
+  `;
+      const data = await query(url, doc, {
+        cidHash: normalizedCidHash,
+        first: Math.min(Math.max(1, Number(first || 100)), 500),
+        skip: Number(skip || 0)
+      });
+      return mapSafe(data?.premiumHolderBalances, (h) => {
+        const holder = safeGetAddress(h.holder);
+        if (!holder) return null;
+        return {
+          id: String(h.id),
+          cidHash: String(h.cidHash),
+          holder,
+          balance: BigInt(String(h.balance || "0")),
+          updatedAt: Number(h.updatedAt || 0)
+        };
+      });
     }
-    function buildSetPriceTx({ marketplace, key, price }) {
-      const to = normaliseAddress(marketplace, "marketplace");
-      const k = toBytes32Key(key);
-      const iface = new Interface(ABI.PersonalMarketplace);
-      const data = iface.encodeFunctionData("setPrice", [k, BigInt(price)]);
-      return { to, data, value: 0n };
+    async function getRevSplit({ url, subdao }) {
+      const addr = safeGetAddress(subdao);
+      if (!addr) throw new Error("invalid subdao address");
+      const doc = `
+    query($id: ID!) {
+      premiumRevSplit(id: $id) {
+        id
+        subdao
+        treasuryBps
+        protocolBps
+        creatorBps
+        updatedAt
+      }
     }
-    function buildBuyTx({ marketplace, creator, key, expectedPrice, deadline }) {
-      const to = normaliseAddress(marketplace, "marketplace");
-      const iface = new Interface(ABI.PersonalMarketplace);
-      const data = iface.encodeFunctionData("purchase", [
-        normaliseAddress(creator, "creator"),
-        toBytes32Key(key),
-        BigInt(expectedPrice),
-        BigInt(deadline)
-      ]);
-      return { to, data, value: 0n };
+  `;
+      const data = await query(url, doc, { id: addr.toLowerCase() });
+      const split = data?.premiumRevSplit;
+      if (!split) return null;
+      return {
+        id: String(split.id),
+        subdao: safeGetAddress(split.subdao) || addr,
+        treasuryBps: Number(split.treasuryBps || 0),
+        protocolBps: Number(split.protocolBps || 0),
+        creatorBps: Number(split.creatorBps || 0),
+        updatedAt: Number(split.updatedAt || 0)
+      };
     }
     module2.exports = {
-      buildCreatePersonalRegistryTx,
-      buildSetPriceTx,
-      buildBuyTx,
-      ...require_receipt(),
-      ...require_access()
+      listPremiumPrompts,
+      getPremiumPrompt,
+      listPremiumPurchases,
+      hasPurchased,
+      getHolderBalance,
+      listHolders,
+      getRevSplit
     };
   }
 });
@@ -8649,6 +9789,335 @@ var require_contributions = __commonJS({
   }
 });
 
+// src/browser/reputation.js
+var require_reputation = __commonJS({
+  "src/browser/reputation.js"(exports2, module2) {
+    var { getAddress } = require_utils();
+    var subgraph = require_subgraph2();
+    function safeGetAddress(value) {
+      try {
+        return getAddress(value);
+      } catch {
+        return null;
+      }
+    }
+    function clampInt(value, { min = 1, max = 100, fallback = 100 } = {}) {
+      const n = Number(value);
+      if (!Number.isFinite(n)) return fallback;
+      return Math.min(max, Math.max(min, Math.trunc(n)));
+    }
+    function toBigIntString(value, fallback = "0") {
+      try {
+        if (typeof value === "bigint") return value.toString();
+        if (typeof value === "number") return String(Math.trunc(value));
+        const str = String(value).trim();
+        if (!str) return fallback;
+        if (!/^-?\d+$/.test(str)) return fallback;
+        return str;
+      } catch {
+        return fallback;
+      }
+    }
+    function mapSafe(list, mapper) {
+      const out = [];
+      for (const item of list || []) {
+        try {
+          const v = mapper(item);
+          if (v != null) out.push(v);
+        } catch {
+        }
+      }
+      return out;
+    }
+    async function getBadgesByRecipient({ url, recipient, first = 50 }) {
+      if (!url) throw new Error("subgraph url required");
+      if (!recipient) throw new Error("recipient required");
+      const addr = safeGetAddress(recipient);
+      if (!addr) throw new Error("invalid recipient address");
+      const doc = `
+    query($recipient: Bytes!, $first: Int!) {
+      soulboundBadges(
+        where: { recipient: $recipient }
+        first: $first
+        orderBy: blockTimestamp
+        orderDirection: desc
+      ) {
+        id
+        contract
+        badgeId
+        recipient
+        evidenceURI
+        blockNumber
+        blockTimestamp
+        transactionHash
+      }
+    }
+  `;
+      const data = await subgraph.query(url, doc, {
+        recipient: addr.toLowerCase(),
+        first: clampInt(first, { min: 1, max: 100, fallback: 50 })
+      });
+      return mapSafe(data?.soulboundBadges, (row) => {
+        const contract = safeGetAddress(row.contract);
+        const recipientAddr = safeGetAddress(row.recipient);
+        if (!contract || !recipientAddr) return null;
+        return {
+          id: String(row.id),
+          contract,
+          badgeId: toBigIntString(row.badgeId, "0"),
+          recipient: recipientAddr,
+          evidenceURI: row.evidenceURI || null,
+          blockNumber: Number(row.blockNumber || 0),
+          blockTimestamp: Number(row.blockTimestamp || 0),
+          transactionHash: row.transactionHash || null
+        };
+      });
+    }
+    async function listContributions({ url, contributor, subdao, first = 50, orderBy = "updatedAt", orderDirection = "desc" }) {
+      if (!url) throw new Error("subgraph url required");
+      const filters = [];
+      if (contributor) {
+        const addr = safeGetAddress(contributor);
+        if (!addr) throw new Error("invalid contributor address");
+        filters.push(`contributor: "${addr.toLowerCase()}"`);
+      }
+      if (subdao) {
+        const addr = safeGetAddress(subdao);
+        if (!addr) throw new Error("invalid subdao address");
+        filters.push(`dao: "${addr.toLowerCase()}"`);
+      }
+      const where = filters.length ? `where: { ${filters.join(", ")} }` : "";
+      const safeOrderBy = ["updatedAt", "createdAt"].includes(orderBy) ? orderBy : "updatedAt";
+      const safeOrderDirection = orderDirection === "asc" ? "asc" : "desc";
+      const doc = `
+    query($first: Int!) {
+      promptContributions(
+        ${where}
+        first: $first
+        orderBy: ${safeOrderBy}
+        orderDirection: ${safeOrderDirection}
+      ) {
+        id
+        dao
+        promptKey
+        contributor
+        cid
+        proposalId
+        forVotes
+        againstVotes
+        abstainVotes
+        uniqueVoters
+        quorum
+        fromBounty
+        bountyId
+        badgeId
+        badgeEvidenceURI
+        createdAt
+        updatedAt
+        transactionHash
+      }
+    }
+  `;
+      const data = await subgraph.query(url, doc, {
+        first: clampInt(first, { min: 1, max: 100, fallback: 50 })
+      });
+      return mapSafe(data?.promptContributions, (row) => {
+        const dao = safeGetAddress(row.dao);
+        const contributorAddr = safeGetAddress(row.contributor);
+        if (!dao) return null;
+        return {
+          id: String(row.id),
+          dao,
+          promptKey: String(row.promptKey),
+          contributor: contributorAddr || "0x0000000000000000000000000000000000000000",
+          cid: String(row.cid),
+          timestamp: Number(row.updatedAt || 0),
+          createdAt: Number(row.createdAt || 0),
+          updatedAt: Number(row.updatedAt || 0),
+          transactionHash: row.transactionHash || null,
+          proposalId: row.proposalId != null ? toBigIntString(row.proposalId) : null,
+          forVotes: row.forVotes != null ? toBigIntString(row.forVotes) : null,
+          againstVotes: row.againstVotes != null ? toBigIntString(row.againstVotes) : null,
+          abstainVotes: row.abstainVotes != null ? toBigIntString(row.abstainVotes) : null,
+          uniqueVoters: row.uniqueVoters != null ? Number(row.uniqueVoters) : null,
+          quorum: row.quorum != null ? toBigIntString(row.quorum) : null,
+          fromBounty: Boolean(row.fromBounty),
+          bountyId: row.bountyId != null ? toBigIntString(row.bountyId) : null,
+          badgeId: row.badgeId != null ? toBigIntString(row.badgeId) : null,
+          badgeEvidenceURI: row.badgeEvidenceURI || null
+        };
+      });
+    }
+    function computeAggregates(contributions) {
+      if (!contributions || contributions.length === 0) {
+        return {
+          totalContributions: 0,
+          uniqueContributors: 0,
+          bountyOriginated: 0,
+          governanceOriginated: 0,
+          totalForVotes: "0",
+          totalAgainstVotes: "0",
+          averageVoterCount: 0,
+          badgeCount: 0
+        };
+      }
+      const contributorSet = /* @__PURE__ */ new Set();
+      let bountyOriginated = 0;
+      let governanceOriginated = 0;
+      let totalForVotes = 0n;
+      let totalAgainstVotes = 0n;
+      let voterCountSum = 0;
+      let voterCountN = 0;
+      let badgeCount = 0;
+      for (const c of contributions) {
+        if (c.contributor) contributorSet.add(c.contributor.toLowerCase());
+        if (c.fromBounty) {
+          bountyOriginated++;
+        } else {
+          governanceOriginated++;
+        }
+        if (c.forVotes != null) {
+          try {
+            totalForVotes += BigInt(c.forVotes);
+          } catch {
+          }
+        }
+        if (c.againstVotes != null) {
+          try {
+            totalAgainstVotes += BigInt(c.againstVotes);
+          } catch {
+          }
+        }
+        if (c.uniqueVoters != null) {
+          voterCountSum += c.uniqueVoters;
+          voterCountN++;
+        }
+        if (c.badgeId != null) badgeCount++;
+      }
+      return {
+        totalContributions: contributions.length,
+        uniqueContributors: contributorSet.size,
+        bountyOriginated,
+        governanceOriginated,
+        totalForVotes: totalForVotes.toString(),
+        totalAgainstVotes: totalAgainstVotes.toString(),
+        averageVoterCount: voterCountN > 0 ? Math.round(voterCountSum / voterCountN) : 0,
+        badgeCount
+      };
+    }
+    async function getByAddress({
+      url,
+      address,
+      subdao,
+      includeBadges = true,
+      includeContributions = true,
+      first = 100
+    } = {}) {
+      if (!url) throw new Error("subgraph url required");
+      if (!address) throw new Error("address required");
+      const addr = safeGetAddress(address);
+      if (!addr) throw new Error("invalid address");
+      const subdaoAddr = subdao ? safeGetAddress(subdao) : null;
+      if (subdao && !subdaoAddr) throw new Error("invalid subdao address");
+      const limit = clampInt(first, { min: 1, max: 200, fallback: 100 });
+      let badges = void 0;
+      if (includeBadges) {
+        badges = await getBadgesByRecipient({ url, recipient: addr, first: limit });
+      }
+      let contributionAggregates = void 0;
+      let lastContributionAt = null;
+      if (includeContributions) {
+        const rows = await listContributions({
+          url,
+          contributor: addr,
+          subdao: subdaoAddr || void 0,
+          first: limit,
+          orderBy: "updatedAt",
+          orderDirection: "desc"
+        });
+        if (rows && rows.length) {
+          const updatedAt = rows[0]?.updatedAt ?? rows[0]?.timestamp ?? null;
+          lastContributionAt = updatedAt != null ? Number(updatedAt) : null;
+          if (!Number.isFinite(lastContributionAt)) lastContributionAt = null;
+        }
+        contributionAggregates = computeAggregates(rows || []);
+      }
+      const signals = {
+        badgeCount: includeBadges ? badges ? badges.length : 0 : null,
+        totalContributions: includeContributions ? contributionAggregates ? contributionAggregates.totalContributions : 0 : null,
+        governanceOriginated: includeContributions ? contributionAggregates ? contributionAggregates.governanceOriginated : 0 : null,
+        bountyOriginated: includeContributions ? contributionAggregates ? contributionAggregates.bountyOriginated : 0 : null,
+        lastContributionAt: includeContributions ? lastContributionAt : null
+      };
+      const out = {
+        address: addr,
+        subdao: subdaoAddr || null,
+        signals
+      };
+      if (includeBadges) out.badges = badges;
+      if (includeContributions) {
+        out.contributionAggregates = contributionAggregates;
+        out.lastContributionAt = lastContributionAt;
+      }
+      return out;
+    }
+    function normalizeGateInt(value, name) {
+      if (value === void 0 || value === null) return null;
+      const n = Number(value);
+      if (!Number.isFinite(n) || n < 0) {
+        throw new Error(`invalid gate: ${name}`);
+      }
+      return Math.trunc(n);
+    }
+    function normalizeRequiredBadgeIds(value) {
+      const list = Array.isArray(value) ? value : value != null ? [value] : [];
+      const out = [];
+      for (const item of list) {
+        const id2 = toBigIntString(item, "");
+        if (id2) out.push(id2);
+      }
+      return out;
+    }
+    function evaluate(result, gates = {}) {
+      const reasons = [];
+      const minBadges = normalizeGateInt(gates.minBadges, "minBadges");
+      const minContributions = normalizeGateInt(gates.minContributions, "minContributions");
+      const requiredBadges = normalizeRequiredBadgeIds(gates.requireBadges ?? gates.requireBadge);
+      const badgeCount = Number(result?.signals?.badgeCount ?? (result?.badges?.length ?? 0));
+      const totalContributions = Number(result?.signals?.totalContributions ?? (result?.contributionAggregates?.totalContributions ?? 0));
+      if (minBadges != null) {
+        if (!Number.isFinite(badgeCount)) {
+          reasons.push("badges_unavailable");
+        } else if (badgeCount < minBadges) {
+          reasons.push(`minBadges:${badgeCount}<${minBadges}`);
+        }
+      }
+      if (minContributions != null) {
+        if (!Number.isFinite(totalContributions)) {
+          reasons.push("contributions_unavailable");
+        } else if (totalContributions < minContributions) {
+          reasons.push(`minContributions:${totalContributions}<${minContributions}`);
+        }
+      }
+      if (requiredBadges.length) {
+        const have = new Set((result?.badges || []).map((b) => toBigIntString(b?.badgeId, "")).filter(Boolean));
+        for (const req2 of requiredBadges) {
+          if (!have.has(req2)) reasons.push(`missingBadge:${req2}`);
+        }
+      }
+      return { ok: reasons.length === 0, reasons };
+    }
+    module2.exports = {
+      getByAddress,
+      evaluate,
+      // Expose lower-level functions for advanced usage
+      getBadgesByRecipient,
+      listContributions,
+      computeAggregates
+    };
+  }
+});
+
 // src/votingMultiplier/index.js
 var require_votingMultiplier = __commonJS({
   "src/votingMultiplier/index.js"(exports2, module2) {
@@ -12894,6 +14363,7 @@ var require_src = __commonJS({
     var ipns = require_ipns();
     var token = require_token();
     var personal = require_personal();
+    var premium = require_premium();
     var subgraph = require_subgraph();
     var privateTx = require_privateTx();
     var safe = require_safe();
@@ -12902,6 +14372,7 @@ var require_src = __commonJS({
     var boost = require_boost();
     var bounty = require_bounty();
     var contributions = require_contributions();
+    var reputation = require_reputation();
     var votingMultiplier = require_votingMultiplier();
     var auction = require_auction();
     var wallet = require_wallet();
@@ -12947,6 +14418,7 @@ var require_src = __commonJS({
       SageEchoExecutor,
       token,
       personal,
+      premium,
       treasury,
       boost,
       // bond module removed; bonds deprecated in CLI/SDK
@@ -12954,6 +14426,7 @@ var require_src = __commonJS({
       utils: { ...utils, privateTx, safe, time },
       bounty,
       contributions,
+      reputation,
       votingMultiplier,
       auction,
       wallet: Object.assign(wallet, {