@sage-protocol/sdk 0.1.18 → 0.1.23

package/dist/node/index.mjs

@@ -20,7 +20,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.18",
+      version: "0.1.23",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -125,7 +125,12 @@ var require_abi = __commonJS({
       "function userForkCount(address) view returns (uint256)",
       "function forkCount(string) view returns (uint256)",
       "function stake(uint256)",
-      "function unstake(uint256)"
+      "function unstake(uint256)",
+      // Fork functions
+      "function forkSubDAO(string,string)",
+      "function forkSubDAO(string,string,bool)",
+      "function forkSubDAOWithStable(string,string,(uint256,uint256,uint8,bytes32,bytes32))",
+      "function forkSubDAOWithStable(string,string,(uint256,uint256,uint8,bytes32,bytes32),bool)"
     ];
     var Factory = [
       "event SubDAOGovernanceDeployed(address indexed subDAO, address indexed governor, address timelock, address treasury)"
@@ -136,7 +141,6 @@ var require_abi = __commonJS({
       "function stableCreationFee() view returns (uint256)",
       "function stableFeeReceiver() view returns (address)",
       "function stableCreationEnabled() view returns (bool)",
-      "function stablePromptForkFee() view returns (uint256)",
       "function stableForkFee() view returns (uint256)",
       // Core factory reads
       "function timelockMinDelay() view returns (uint256)",
@@ -166,8 +170,8 @@ var require_abi = __commonJS({
       "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)",
       "function createSubDAOOperatorAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer) returns (address subDAO, address registry)",
-      "function createForkedSubDAO(string newName, string newDescription, string originalName, address originalSubDAO, address forker) returns (address subDAO, address registry)",
-      "function createForkedSubDAOWithStable(string newName, string newDescription, string originalName, address originalSubDAO, address forker, uint64 authorizationNonce, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)"
+      "function createForkedSubDAO(string newName, string newDescription, string originalName, address originalSubDAO, address forker, bool copyLibrary) returns (address subDAO, address registry)",
+      "function createForkedSubDAOWithStable(string newName, string newDescription, string originalName, address originalSubDAO, address forker, uint64 authorizationNonce, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit, bool copyLibrary) returns (address subDAO, address registry)"
     ];
     var TemplateModule = [
       "function getActiveTemplates() view returns (uint256[])",
@@ -178,13 +182,19 @@ var require_abi = __commonJS({
       "function maxCreationBurn() view returns (uint256)"
     ];
     var LibraryRegistry = [
-      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version)",
+      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee)",
       "function daoTimelock(address) view returns (address)",
-      "function getLibrary(address) view returns (tuple(string manifestCID, address lastUpdater, uint256 lastUpdated, string version))",
+      "function getLibrary(address) view returns (tuple(string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee))",
+      "function getLibraryForkFee(address dao) view returns (uint256)",
+      "function setLibraryForkFee(address dao, uint256 fee)",
       "function updateLibrary(address dao, string manifestCID, string version)",
       "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 DAORegistered(address indexed dao, address indexed timelock)"
+      "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)"
     ];
     var PromptRegistry = [
       "function prompts(string key) view returns (string cid, uint256 version, uint256 timestamp, address author, string forkedFromCID, address originalAuthor, bool isFork, uint256 forkDepth)",
@@ -1513,19 +1523,656 @@ var require_subgraph = __commonJS({
           updatedAt: Number(p.updatedAt || 0)
         };
       },
-      async getProposalById({ url, id: id2 }) {
+      async getProposalById({ url, id: id2 }) {
+        if (!url) throw new Error("subgraph url required");
+        const doc = `query($id: ID!){ proposal(id:$id){ id proposer description createdAt updatedAt state eta targets values calldatas } }`;
+        const data = await query(url, doc, { id: String(id2) });
+        const p = data?.proposal;
+        if (!p) return null;
+        try {
+          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: String(p.state || ""),
+            eta: p.eta ? BigInt(String(p.eta)) : null,
+            targets,
+            values: (p.values || []).map((v) => BigInt(String(v))),
+            calldatas: p.calldatas || []
+          };
+        } catch {
+          return null;
+        }
+      }
+    };
+  }
+});
+
+// src/adapters/transports.js
+var require_transports = __commonJS({
+  "src/adapters/transports.js"(exports2, module2) {
+    function createTransports({ provider, signer = null, subgraph = null }) {
+      return function resolve(kind) {
+        switch (kind) {
+          case "rpc":
+            return provider;
+          case "signer":
+            return { signer };
+          case "subgraph":
+            return { url: subgraph };
+          default:
+            return null;
+        }
+      };
+    }
+    module2.exports = {
+      createTransports
+    };
+  }
+});
+
+// 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 || []
+        };
+      });
+    }
+    async function listLibraries({ url, subdao, first = 50, skip = 0 }) {
+      const where = subdao ? `where: { subDAO: "${String(subdao).toLowerCase()}" }` : "";
+      const data = await query(url, `
+    query($first: Int!, $skip: Int!) {
+      libraries(${where} first: $first, skip: $skip, orderBy: createdAt, orderDirection: desc) {
+        id
+        manifestCID
+        subDAO
+        proposer
+        createdAt
+      }
+    }
+  `, { first, skip });
+      return mapSafe(data?.libraries, (lib) => {
+        const sub = safeGetAddress(lib.subDAO);
+        const proposer = safeGetAddress(lib.proposer);
+        if (!sub || !proposer) return null;
+        return {
+          id: lib.id,
+          manifestCID: lib.manifestCID,
+          subdao: sub,
+          proposer,
+          createdAt: Number(lib.createdAt || 0)
+        };
+      });
+    }
+    async function getSubdaoLibraries({ url, subdao, first = 20, skip = 0 }) {
+      if (!url) throw new Error("subgraph url required");
+      const hasFilter = !!subdao;
+      const whereClause = hasFilter ? "where:{ subdao:$subdao }" : "";
+      const doc = `
+    query($subdao:Bytes,$first:Int!,$skip:Int!){
+      subDAOLibraryPointers(
+        ${whereClause}
+        first:$first,
+        skip:$skip,
+        orderBy: updatedAt,
+        orderDirection: desc
+      ){
+        id
+        subdao
+        libraryId
+        manifestCID
+        previousCID
+        promptCount
+        updatedAt
+      }
+    }
+  `;
+      const variables = {
+        first: Math.min(Math.max(1, Number(first || 20)), 100),
+        skip
+      };
+      if (hasFilter) {
+        const addr = safeGetAddress(subdao);
+        if (!addr) throw new Error("invalid subdao address");
+        variables.subdao = addr.toLowerCase();
+      }
+      const data = await query(url, doc, variables);
+      return mapSafe(data?.subDAOLibraryPointers, (row) => {
+        const id2 = row?.id;
+        const manifestCID = row?.manifestCID;
+        const sub = safeGetAddress(row?.subdao);
+        if (!id2 || !manifestCID || !sub) return null;
+        return {
+          id: String(id2),
+          subdao: sub,
+          libraryId: String(row.libraryId || "main"),
+          manifestCID: String(manifestCID),
+          previousCID: row.previousCID || null,
+          promptCount: row.promptCount != null ? Number(row.promptCount) : null,
+          updatedAt: row.updatedAt != null ? Number(row.updatedAt) : null
+        };
+      });
+    }
+    async function getSubdaoPrompts({ url, registry, first = 50, skip = 0, orderBy = "updatedAt", orderDirection = "desc" }) {
+      if (!url) throw new Error("subgraph url required");
+      const reg = safeGetAddress(registry);
+      if (!reg) throw new Error("invalid registry address");
+      const safeOrderBy = sanitizeOrderBy(orderBy, ["updatedAt"], "updatedAt");
+      const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
+      const doc = `
+    query($registry:Bytes!,$first:Int!,$skip:Int!){
+      prompts(
+        where:{ registry:$registry },
+        first:$first,
+        skip:$skip,
+        orderBy: ${safeOrderBy},
+        orderDirection: ${safeOrderDirection}
+      ){
+        id
+        key
+        cid
+        version
+        author
+        registry
+        updatedAt
+      }
+    }
+  `;
+      const data = await query(url, doc, {
+        registry: reg.toLowerCase(),
+        first: Math.min(Math.max(1, Number(first || 50)), 100),
+        skip
+      });
+      return mapSafe(data?.prompts, (p) => {
+        const author = safeGetAddress(p.author);
+        const regAddr = safeGetAddress(p.registry);
+        if (!author || !regAddr) return null;
+        return {
+          id: String(p.id),
+          key: String(p.key),
+          cid: String(p.cid),
+          version: BigInt(p.version || "0"),
+          author,
+          registry: regAddr,
+          updatedAt: Number(p.updatedAt || 0)
+        };
+      });
+    }
+    module2.exports = {
+      query,
+      listProposals,
+      listProposalsFiltered,
+      listLibraries,
+      getSubdaoLibraries,
+      getSubdaoPrompts,
+      /**
+       * Canonical proposal timeline. Tries common fields first, then event-style fallbacks.
+       * Returns { id, createdAt, queuedAt, executedAt, canceledAt, eta, state } (numbers/strings may be null when unavailable).
+       */
+      async getProposalTimeline({ url, id: id2 }) {
+        if (!url) throw new Error("subgraph url required");
+        const pid = typeof id2 === "bigint" ? id2.toString() : String(id2);
+        try {
+          const data = await query(url, `
+        query($id: ID!) {
+          proposal(id: $id) {
+            id
+            createdAt
+            updatedAt
+            state
+            eta
+            queuedAt
+            executedAt
+            canceledAt
+          }
+        }
+      `, { id: pid });
+          if (data && data.proposal) {
+            const p = data.proposal;
+            return {
+              id: p.id,
+              createdAt: Number(p.createdAt || 0),
+              queuedAt: p.queuedAt != null ? Number(p.queuedAt) : null,
+              executedAt: p.executedAt != null ? Number(p.executedAt) : null,
+              canceledAt: p.canceledAt != null ? Number(p.canceledAt) : null,
+              eta: p.eta != null ? BigInt(String(p.eta)) : null,
+              state: String(p.state || "")
+            };
+          }
+        } catch (_) {
+        }
+        try {
+          const data = await query(url, `
+        query($id: String!) {
+          proposalEvents(where: { proposal: $id }, orderBy: timestamp, orderDirection: asc) {
+            type
+            timestamp
+          }
+          proposals(where: { id: $id }, first:1) { id createdAt state eta }
+        }
+      `, { id: pid });
+          const events = (data?.proposalEvents || []).map((e) => ({ type: String(e.type || ""), timestamp: Number(e.timestamp || 0) }));
+          const base = data?.proposals?.[0] || {};
+          const find = (t) => events.find((e) => e.type.toLowerCase() === t)?.timestamp || null;
+          return {
+            id: base.id || pid,
+            createdAt: Number(base.createdAt || 0),
+            queuedAt: find("queued"),
+            executedAt: find("executed"),
+            canceledAt: find("canceled") || find("cancelled") || null,
+            eta: base.eta != null ? BigInt(String(base.eta)) : null,
+            state: String(base.state || "")
+          };
+        } catch (_) {
+        }
+        return { id: pid, createdAt: 0, queuedAt: null, executedAt: null, canceledAt: null, eta: null, state: "" };
+      },
+      async listLiquidityAddPlans({ url, subdao = null, first = 50, skip = 0, orderBy = "blockTimestamp", orderDirection = "desc" }) {
+        if (!url) throw new Error("subgraph url required");
+        const filters = [];
+        if (subdao) {
+          const addr = safeGetAddress(subdao);
+          if (!addr) throw new Error("invalid subdao address");
+          filters.push(`subdao: "${addr.toLowerCase()}"`);
+        }
+        const where = filters.length ? `where: { ${filters.join(", ")} }` : "";
+        const safeOrderBy = sanitizeOrderBy(orderBy, ["blockTimestamp", "blockNumber"], "blockTimestamp");
+        const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
+        const doc = `
+      query($first:Int!,$skip:Int!){
+        liquidityAddPlans(${where} first:$first, skip:$skip, orderBy: ${safeOrderBy}, orderDirection: ${safeOrderDirection}){
+          id subdao pool sxxxToken stableToken sxxxAmount stableAmount lpRecipient blockNumber blockTimestamp transactionHash
+}
+      }
+    `;
+        const data = await query(url, doc, { first, skip });
+        return mapSafe(data?.liquidityAddPlans, (e) => {
+          const sub = safeGetAddress(e.subdao);
+          const pool = safeGetAddress(e.pool);
+          const sxxxToken = safeGetAddress(e.sxxxToken);
+          const stableToken = safeGetAddress(e.stableToken);
+          const lpRecipient = safeGetAddress(e.lpRecipient);
+          if (!sub || !pool || !sxxxToken || !stableToken || !lpRecipient) return null;
+          return {
+            id: String(e.id),
+            subdao: sub,
+            pool,
+            sxxxToken,
+            stableToken,
+            sxxxAmount: BigInt(String(e.sxxxAmount)),
+            stableAmount: BigInt(String(e.stableAmount)),
+            lpRecipient,
+            blockNumber: Number(e.blockNumber || 0),
+            blockTimestamp: Number(e.blockTimestamp || 0),
+            transactionHash: e.transactionHash
+          };
+        });
+      },
+      async listLiquidityRemovePlans({ url, subdao = null, first = 50, skip = 0, orderBy = "blockTimestamp", orderDirection = "desc" }) {
+        if (!url) throw new Error("subgraph url required");
+        const filters = [];
+        if (subdao) {
+          const addr = safeGetAddress(subdao);
+          if (!addr) throw new Error("invalid subdao address");
+          filters.push(`subdao: "${addr.toLowerCase()}"`);
+        }
+        const where = filters.length ? `where: { ${filters.join(", ")} }` : "";
+        const safeOrderBy = sanitizeOrderBy(orderBy, ["blockTimestamp", "blockNumber"], "blockTimestamp");
+        const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
+        const doc = `
+      query($first:Int!,$skip:Int!){
+        liquidityRemovePlans(${where} first:$first, skip:$skip, orderBy: ${safeOrderBy}, orderDirection: ${safeOrderDirection}){
+          id subdao pool lpToken lpAmount recipient blockNumber blockTimestamp transactionHash
+        }
+      }
+    `;
+        const data = await query(url, doc, { first, skip });
+        return mapSafe(data?.liquidityRemovePlans, (e) => {
+          const sub = safeGetAddress(e.subdao);
+          const pool = safeGetAddress(e.pool);
+          const lpToken = safeGetAddress(e.lpToken);
+          const recipient = safeGetAddress(e.recipient);
+          if (!sub || !pool || !lpToken || !recipient) return null;
+          return {
+            id: String(e.id),
+            subdao: sub,
+            pool,
+            lpToken,
+            lpAmount: BigInt(String(e.lpAmount)),
+            recipient,
+            blockNumber: Number(e.blockNumber || 0),
+            blockTimestamp: Number(e.blockTimestamp || 0),
+            transactionHash: e.transactionHash
+          };
+        });
+      },
+      async listPromptsByTag({ url, tagsHash, registry = null, first = 50, skip = 0, orderBy = "updatedAt", orderDirection = "desc" }) {
+        if (!url) throw new Error("subgraph url required");
+        const clauses = [`tagsHash: "${String(tagsHash)}"`];
+        if (registry) {
+          const addr = safeGetAddress(registry);
+          if (!addr) throw new Error("invalid registry address");
+          clauses.push(`registry: "${addr.toLowerCase()}"`);
+        }
+        const where = `where: { ${clauses.join(", ")} }`;
+        const safeOrderBy = sanitizeOrderBy(orderBy, ["updatedAt"], "updatedAt");
+        const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
+        const doc = `
+      query($first:Int!,$skip:Int!) {
+        prompts(${where} first:$first, skip:$skip, orderBy: ${safeOrderBy}, orderDirection: ${safeOrderDirection}) {
+          id key cid version author registry updatedAt tagsHash
+        }
+      }
+    `;
+        const data = await query(url, doc, { first, skip });
+        return mapSafe(data?.prompts, (p) => {
+          const author = safeGetAddress(p.author);
+          const regAddr = safeGetAddress(p.registry);
+          if (!author || !regAddr) return null;
+          return {
+            id: String(p.id),
+            key: String(p.key),
+            cid: String(p.cid),
+            version: BigInt(p.version || "0"),
+            author,
+            registry: regAddr,
+            updatedAt: Number(p.updatedAt || 0),
+            tagsHash: String(p.tagsHash || "")
+          };
+        });
+      },
+      // Prompt helpers (registry scoped)
+      async listRegistryPrompts({ url, registry, first = 50, skip = 0, orderBy = "updatedAt", orderDirection = "desc" }) {
+        if (!url) throw new Error("subgraph url required");
+        const reg = safeGetAddress(registry);
+        if (!reg) throw new Error("invalid registry address");
+        const safeOrderBy = sanitizeOrderBy(orderBy, ["updatedAt"], "updatedAt");
+        const safeOrderDirection = sanitizeOrderDirection(orderDirection, "desc");
+        const doc = `
+      query($first:Int!,$skip:Int!,$registry:Bytes!) {
+        prompts(where:{ registry: $registry }, first:$first, skip:$skip, orderBy: ${safeOrderBy}, orderDirection: ${safeOrderDirection}) {
+          id
+          key
+          cid
+          version
+          author
+          registry
+          updatedAt
+        }
+      }
+    `;
+        const data = await query(url, doc, { first, skip, registry: reg.toLowerCase() });
+        return mapSafe(data?.prompts, (p) => {
+          const author = safeGetAddress(p.author);
+          const regAddr = safeGetAddress(p.registry);
+          if (!author || !regAddr) return null;
+          return {
+            id: String(p.id),
+            key: String(p.key),
+            cid: String(p.cid),
+            version: BigInt(p.version || "0"),
+            author,
+            registry: regAddr,
+            updatedAt: Number(p.updatedAt || 0)
+          };
+        });
+      },
+      async getPromptByKey({ url, registry, key }) {
+        if (!url) throw new Error("subgraph url required");
+        const reg = safeGetAddress(registry);
+        if (!reg) throw new Error("invalid registry address");
+        const doc = `
+      query($registry:Bytes!,$key:String!) {
+        prompts(where:{ registry: $registry, key: $key }, first:1) {
+          id
+          key
+          cid
+          version
+          author
+          registry
+          updatedAt
+        }
+      }
+    `;
+        const data = await query(url, doc, { registry: reg.toLowerCase(), key: String(key) });
+        const p = (data?.prompts || [])[0];
+        if (!p) return null;
+        const author = safeGetAddress(p.author);
+        const regAddr = safeGetAddress(p.registry);
+        if (!author || !regAddr) return null;
+        return {
+          id: String(p.id),
+          key: String(p.key),
+          cid: String(p.cid),
+          version: BigInt(p.version || "0"),
+          author,
+          registry: regAddr,
+          updatedAt: Number(p.updatedAt || 0)
+        };
+      },
+      async getProposalById({ url, id: id2, governor }) {
         if (!url) throw new Error("subgraph url required");
-        const doc = `query($id: ID!){ proposal(id:$id){ id proposer description createdAt updatedAt state eta targets values calldatas } }`;
-        const data = await query(url, doc, { id: String(id2) });
-        const p = data?.proposal;
+        let p = null;
+        if (governor) {
+          const govLower = String(governor).toLowerCase();
+          const compositeId = `${govLower}-${String(id2)}`;
+          const doc = `query($id: ID!){ proposal(id:$id){ id proposer description createdAt updatedAt state eta targets values calldatas } }`;
+          const data = await query(url, doc, { id: compositeId });
+          p = data?.proposal;
+        }
+        if (!p && governor) {
+          const govLower = String(governor).toLowerCase();
+          const doc = `query($gov: Bytes!, $first: Int!){ proposals(where:{governor:$gov}, first:$first, orderBy:createdAt, orderDirection:desc){ id proposer description createdAt updatedAt state eta targets values calldatas } }`;
+          const data = await query(url, doc, { gov: govLower, first: 100 });
+          const proposals = data?.proposals || [];
+          p = proposals.find((prop) => {
+            const parts = String(prop.id || "").split("-");
+            const propId = parts.length > 1 ? parts[parts.length - 1] : prop.id;
+            return String(propId) === String(id2) || propId && String(BigInt(propId)) === String(BigInt(id2));
+          });
+        }
         if (!p) return null;
         try {
           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;
+          const idParts = String(p.id || "").split("-");
+          const actualId = idParts.length > 1 ? idParts[idParts.length - 1] : p.id;
           return {
-            id: BigInt(p.id),
+            id: BigInt(actualId),
             proposer,
             description: p.description || "",
             createdAt: Number(p.createdAt || 0),
@@ -1544,29 +2191,6 @@ var require_subgraph = __commonJS({
   }
 });
 
-// src/adapters/transports.js
-var require_transports = __commonJS({
-  "src/adapters/transports.js"(exports2, module2) {
-    function createTransports({ provider, signer = null, subgraph = null }) {
-      return function resolve(kind) {
-        switch (kind) {
-          case "rpc":
-            return provider;
-          case "signer":
-            return { signer };
-          case "subgraph":
-            return { url: subgraph };
-          default:
-            return null;
-        }
-      };
-    }
-    module2.exports = {
-      createTransports
-    };
-  }
-});
-
 // src/ipfs/index.js
 var require_ipfs = __commonJS({
   "src/ipfs/index.js"(exports2, module2) {
@@ -1756,7 +2380,6 @@ var require_ipfs = __commonJS({
             headers["X-Wallet-Address"] = auth.address;
             headers["X-Wallet-Signature"] = auth.signature;
             headers["X-Wallet-Nonce"] = auth.nonce;
-            headers["X-Wallet-Message"] = auth.message;
           }
           return { headers, auth };
         }
@@ -1777,8 +2400,7 @@ var require_ipfs = __commonJS({
             ...extraHeaders,
             "X-Wallet-Address": auth.address,
             "X-Wallet-Signature": auth.signature,
-            "X-Wallet-Nonce": auth.nonce,
-            "X-Wallet-Message": auth.message
+            "X-Wallet-Nonce": auth.nonce
           };
           return { headers, auth };
         }
@@ -1799,6 +2421,13 @@ var require_ipfs = __commonJS({
           order.push(name);
         };
         const normalizedPreference = Array.isArray(preference) ? preference.map((p) => toLowerSafe(p)).filter(Boolean) : preference ? [toLowerSafe(preference)].filter(Boolean) : [];
+        if (process.env.SAGE_DEBUG_WORKER === "1") {
+          console.log("[SDK DEBUG] resolveProviderOrder preference:", preference);
+          console.log("[SDK DEBUG] normalizedPreference:", normalizedPreference);
+          console.log("[SDK DEBUG] config.provider:", config.provider);
+          console.log("[SDK DEBUG] shouldUseWorker():", shouldUseWorker());
+          console.log("[SDK DEBUG] hasPinataCreds():", hasPinataCreds());
+        }
         normalizedPreference.forEach(append);
         if (shouldUseWorker()) append("worker");
         if (hasPinataCreds()) append("pinata");
@@ -1806,17 +2435,90 @@ var require_ipfs = __commonJS({
         if (config.simulate) append("simulate");
         return order;
       }
-      async function uploadViaWorker(payload, { warm, gateways } = {}) {
+      async function uploadViaWorker(payload, { warm, gateways, pin: pin2 } = {}) {
+        const uploadUrl = workerUrl("upload");
+        if (process.env.SAGE_DEBUG_WORKER === "1") {
+          console.log("[SDK DEBUG] uploadViaWorker called");
+          console.log("[SDK DEBUG]   workerBaseUrl:", workerBaseUrl());
+          console.log("[SDK DEBUG]   uploadUrl:", uploadUrl);
+          console.log("[SDK DEBUG]   workerHasAuth:", workerHasAuth());
+        }
         const { headers, auth } = await buildWorkerAuthHeaders({ "Content-Type": "application/json" });
         const body = { ...payload };
         if (auth) body.auth = auth;
-        const response = await axiosInstance.post(workerUrl("upload"), body, { headers, timeout: config.timeoutMs });
-        const cid = response?.data?.cid || response?.data?.IpfsHash;
+        if (pin2) {
+          body.pin = typeof pin2 === "string" ? { duration: pin2 } : pin2;
+        }
+        if (process.env.SAGE_DEBUG_WORKER === "1") {
+          console.log("[SDK DEBUG]   headers:", Object.keys(headers));
+          console.log("[SDK DEBUG]   hasAuth:", !!auth);
+          if (pin2) console.log("[SDK DEBUG]   pin:", JSON.stringify(body.pin));
+        }
+        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.duration = data2?.duration;
+            error.accepts = data2?.accepts;
+            error.response = data2;
+            throw error;
+          }
+          throw uploadErr;
+        }
+        const data = response?.data || {};
+        const cid = data.cid || data.IpfsHash;
+        if (response?.status === 202 || data.status === "pending_review") {
+          return {
+            cid: cid || null,
+            provider: "worker",
+            status: "pending_review",
+            categories: data.categories || [],
+            response: data
+          };
+        }
         if (!cid) {
           throw new Error("Worker response missing cid");
         }
         if (warm || config.shouldWarm) await warmGateways(cid, { gateways });
-        return { cid, provider: "worker", response: response?.data || null };
+        const result = {
+          cid,
+          provider: "worker",
+          response: data
+        };
+        if (data.moderation) {
+          result.moderation = data.moderation;
+        }
+        if (data.pinned !== void 0) {
+          result.pinned = data.pinned;
+          result.expiresAt = data.expiresAt;
+          result.creditsPaid = data.creditsPaid;
+          result.urls = data.urls;
+        }
+        return result;
       }
       async function uploadToPinata(payload, { filename = "payload.json", metadata, warm, gateways } = {}) {
         if (!hasPinataCreds()) {
@@ -1894,7 +2596,7 @@ var require_ipfs = __commonJS({
         return { cid, provider: "simulate" };
       }
       async function uploadPayload(payload, options2 = {}) {
-        const { providers, provider, warm, gateways, filename, metadata } = options2;
+        const { providers, provider, warm, gateways, filename, metadata, pin: pin2 } = options2;
         const order = resolveProviderOrder(providers || provider);
         if (!order.length) {
           throw new Error("No IPFS providers configured. Set Pinata credentials, worker upload, or enable test mode");
@@ -1903,7 +2605,7 @@ var require_ipfs = __commonJS({
         for (const candidate of order) {
           try {
             if (candidate === "worker") {
-              return await uploadViaWorker(payload, { warm, gateways });
+              return await uploadViaWorker(payload, { warm, gateways, pin: pin2 });
             }
             if (candidate === "pinata") {
               return await uploadToPinata(payload, { filename, metadata, warm, gateways });
@@ -1915,6 +2617,9 @@ var require_ipfs = __commonJS({
               return await uploadSimulated(payload, { warm, gateways });
             }
           } catch (error2) {
+            if (error2.code === "CONTENT_BLOCKED" || error2.code === "PAYMENT_REQUIRED") {
+              throw error2;
+            }
             errors.push({ provider: candidate, error: error2 });
           }
         }
@@ -1923,7 +2628,7 @@ var require_ipfs = __commonJS({
         throw error;
       }
       async function uploadPrompt(options2 = {}) {
-        const { prompt, providers, provider, warm, gateways } = options2;
+        const { prompt, providers, provider, warm, gateways, pin: pin2 } = options2;
         if (!prompt || typeof prompt !== "object") {
           throw new Error("prompt payload required");
         }
@@ -1949,6 +2654,7 @@ var require_ipfs = __commonJS({
           provider,
           warm,
           gateways,
+          pin: pin2,
           filename: `${prompt.name || "prompt"}.json`,
           metadata
         });
@@ -2183,8 +2889,7 @@ var require_ipfs = __commonJS({
         "Content-Type": "application/json",
         "X-Wallet-Address": address,
         "X-Wallet-Signature": signature,
-        "X-Wallet-Nonce": nonce,
-        "X-Wallet-Message": message
+        "X-Wallet-Nonce": nonce
       };
       let verified = false;
       try {
@@ -2428,6 +3133,15 @@ var require_validation = __commonJS({
         path2.join(__dirname, "..", "..", "docs", "schemas", "manifest.schema.json")
       ];
     }
+    function normaliseV3SchemaPaths(v3SchemaPaths, { path: path2 }) {
+      if (Array.isArray(v3SchemaPaths) && v3SchemaPaths.length) {
+        return v3SchemaPaths;
+      }
+      return [
+        path2.join(process.cwd(), "docs", "schemas", "manifest.v3.schema.json"),
+        path2.join(__dirname, "..", "..", "docs", "schemas", "manifest.v3.schema.json")
+      ];
+    }
     function safeJsonParse(fs2, file) {
       try {
         const raw = fs2.readFileSync(file, "utf8");
@@ -2436,17 +3150,17 @@ var require_validation = __commonJS({
         return null;
       }
     }
-    function deriveHints(errors = []) {
+    function deriveHints(errors = [], { version = "2.0.0" } = {}) {
       const hints = /* @__PURE__ */ new Set();
       for (const err of errors) {
         const keyword = (err.keyword || "").toLowerCase();
         const instancePath = err.instancePath || "/";
         const message = (err.message || "").toLowerCase();
         if (keyword === "required" && instancePath === "/") {
-          hints.add('Add a top-level "library" object and set "version": "2.0.0"');
+          hints.add('Add a top-level "library" object and set "version": "3.0.0"');
         }
         if (message.includes("version") || instancePath === "/version") {
-          hints.add('Ensure "version" is exactly the semver string "2.0.0"');
+          hints.add('Ensure "version" is exactly the semver string "3.0.0"');
         }
         if (keyword === "required" && instancePath.includes("/prompts")) {
           hints.add('Each prompt should define a unique "key"');
@@ -2460,17 +3174,23 @@ var require_validation = __commonJS({
         path: path2 = pathDefault,
         ajvFactory = defaultAjvFactory,
         addFormats = defaultAddFormats,
-        schemaPaths
+        schemaPaths,
+        v3SchemaPaths
       } = options;
       const searchPaths = normaliseSchemaPaths(schemaPaths, { path: path2 });
-      function loadSchema() {
-        for (const schemaPath of searchPaths) {
+      const v3SearchPaths = normaliseV3SchemaPaths(v3SchemaPaths, { path: path2 });
+      function loadSchema(version = "2.0.0") {
+        const paths = version === "3.0.0" ? v3SearchPaths : searchPaths;
+        for (const schemaPath of paths) {
           if (!fs2.existsSync(schemaPath)) continue;
           const schema = safeJsonParse(fs2, schemaPath);
           if (schema) return { schema, schemaPath };
         }
         return { schema: null, schemaPath: null };
       }
+      function detectVersion(manifest) {
+        return "3.0.0";
+      }
       function lintManifest(manifest, { enforceVersion = true, manifestPath = null } = {}) {
         if (!manifest || typeof manifest !== "object") {
           return {
@@ -2483,16 +3203,18 @@ var require_validation = __commonJS({
             manifestPath
           };
         }
-        const { schema, schemaPath } = loadSchema();
+        const detectedVersion = detectVersion(manifest);
+        const { schema, schemaPath } = loadSchema(detectedVersion);
         if (!schema) {
+          const schemaFile = detectedVersion === "3.0.0" ? "manifest.v3.schema.json" : "manifest.schema.json";
           return {
             ok: false,
             versionOk: false,
             missingSchema: true,
             schemaPath: null,
-            errors: [{ keyword: "schema", instancePath: "/", message: "manifest schema not found" }],
+            errors: [{ keyword: "schema", instancePath: "/", message: `manifest schema not found for version ${detectedVersion}` }],
             hints: [
-              'Ensure docs/schemas/manifest.schema.json exists (run "sage project scaffold" to regenerate)'
+              `Ensure docs/schemas/${schemaFile} exists (run "sage project scaffold" to regenerate)`
             ],
             manifestPath
           };
@@ -2511,19 +3233,19 @@ var require_validation = __commonJS({
         let versionOk = true;
         const version = manifest?.version;
         if (valid && enforceVersion) {
-          const isV2Semver = typeof version === "string" && version.trim() === "2.0.0";
-          versionOk = isV2Semver;
+          const isValidVersion = detectedVersion === "3.0.0" ? typeof version === "string" && version.trim() === "3.0.0" : typeof version === "string" && version.trim() === "2.0.0";
+          versionOk = isValidVersion;
           if (!versionOk) {
             validationErrors.push({
               keyword: "const",
               instancePath: "/version",
-              message: 'version must be the semver string "2.0.0"',
+              message: `version must be the semver string "${detectedVersion}"`,
               schemaPath: "#/properties/version",
-              params: { allowedValue: "2.0.0" }
+              params: { allowedValue: detectedVersion }
             });
           }
         }
-        const hints = deriveHints(validationErrors);
+        const hints = deriveHints(validationErrors, { version: detectedVersion });
         return {
           ok: valid && versionOk,
           versionOk,
@@ -2532,7 +3254,8 @@ var require_validation = __commonJS({
           errors: validationErrors,
           hints,
           manifestPath,
-          version
+          version,
+          detectedVersion
         };
       }
       function lintManifestFile(manifestPath, options2 = {}) {
@@ -2604,6 +3327,7 @@ var require_validation = __commonJS({
       }
       return {
         loadSchema,
+        detectVersion,
         lintManifest,
         lintManifestFile,
         bestPracticeCheck,
@@ -2701,7 +3425,6 @@ var require_library = __commonJS({
       ]);
       return { to, data, value: 0n };
     }
-    var buildUpdateLibraryForSubDAOTx = buildUpdateLibraryTx;
     module2.exports = {
       listManifests,
       getManifestInfo,
@@ -2709,7 +3432,6 @@ var require_library = __commonJS({
       getLatestLibrary,
       hasScopedOwnership,
       buildUpdateLibraryTx,
-      buildUpdateLibraryForSubDAOTx,
       _computeLibraryKey,
       getBeforeAfterForUpdate,
       /** Build an authorizeTimelock(timelock, subdao) call for a LibraryRegistry. */
@@ -2829,12 +3551,35 @@ var require_governance = __commonJS({
         votes: { against, for: _for, abstain }
       };
     }
-    async function listProposals({ provider, governor, fromBlock = 0, toBlock = "latest" }) {
+    async function listProposals({ provider, governor, fromBlock, toBlock = "latest", subgraphUrl }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normaliseGovernor(governor);
+      const sgUrl = subgraphUrl || process.env.SAGE_SUBGRAPH_URL || process.env.SUBGRAPH_URL || null;
+      if (sgUrl) {
+        try {
+          const browserSubgraph = require_subgraph2();
+          const sgProposals = await browserSubgraph.listProposals({ url: sgUrl, governor: addr, first: 100 });
+          if (sgProposals && sgProposals.length > 0) {
+            return sgProposals.map((p) => ({
+              id: BigInt(p.id),
+              proposer: p.proposer,
+              targets: p.targets || [],
+              values: (p.values || []).map((v) => BigInt(v)),
+              calldatas: p.calldatas || [],
+              signatures: [],
+              description: p.description || "",
+              descriptionHash: p.description ? hashDescription(p.description) : null,
+              createdAt: p.createdAt
+            }));
+          }
+        } catch (_) {
+        }
+      }
+      const currentBlock = await provider.getBlockNumber();
+      const effectiveFromBlock = fromBlock !== void 0 ? fromBlock : Math.max(0, currentBlock - 5e4);
       const iface = new Interface([ABI.Events.ProposalCreated]);
       const topic = iface.getEvent("ProposalCreated").topicHash;
-      const logs = await provider.getLogs({ address: addr, fromBlock, toBlock, topics: [topic] });
+      const logs = await provider.getLogs({ address: addr, fromBlock: effectiveFromBlock, toBlock, topics: [topic] });
       const proposals = [];
       for (const log of logs) {
         try {
@@ -2847,7 +3592,8 @@ var require_governance = __commonJS({
             calldatas: parsed.args.calldatas.map((data) => hexlify(data)),
             signatures: parsed.args.signatures ? parsed.args.signatures.map(String) : [],
             description: parsed.args.description,
-            descriptionHash: hashDescription(parsed.args.description)
+            descriptionHash: hashDescription(parsed.args.description),
+            blockNumber: log.blockNumber
           });
         } catch (err) {
           continue;
@@ -2855,13 +3601,38 @@ var require_governance = __commonJS({
       }
       return proposals;
     }
-    async function getProposalMetadata({ provider, governor, id: id2, fromBlock = 0, toBlock = "latest" }) {
+    async function getProposalMetadata({ provider, governor, id: id2, fromBlock, toBlock = "latest", subgraphUrl }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normaliseGovernor(governor);
+      const pid = typeof id2 === "bigint" ? id2 : String(id2).startsWith("0x") ? BigInt(id2) : BigInt(String(id2));
+      const sgUrl = subgraphUrl || process.env.SAGE_SUBGRAPH_URL || process.env.SUBGRAPH_URL || null;
+      if (sgUrl) {
+        try {
+          const browserSubgraph = require_subgraph2();
+          const sgProposal = await browserSubgraph.getProposalById({ url: sgUrl, id: String(pid), governor: addr });
+          if (sgProposal && sgProposal.targets) {
+            return {
+              governor: addr,
+              id: pid,
+              proposer: sgProposal.proposer,
+              targets: sgProposal.targets || [],
+              values: (sgProposal.values || []).map((v) => BigInt(v)),
+              calldatas: sgProposal.calldatas || [],
+              signatures: [],
+              description: sgProposal.description || "",
+              descriptionHash: sgProposal.description ? hashDescription(sgProposal.description) : null,
+              blockNumber: sgProposal.createdAt || null,
+              source: "subgraph"
+            };
+          }
+        } catch (_) {
+        }
+      }
+      const currentBlock = await provider.getBlockNumber();
+      const effectiveFromBlock = fromBlock !== void 0 ? fromBlock : Math.max(0, currentBlock - 5e4);
       const iface = new Interface([ABI.Events.ProposalCreated]);
       const topic = iface.getEvent("ProposalCreated").topicHash;
-      const pid = typeof id2 === "bigint" ? id2 : String(id2).startsWith("0x") ? BigInt(id2) : BigInt(String(id2));
-      const logs = await provider.getLogs({ address: addr, fromBlock, toBlock, topics: [topic] });
+      const logs = await provider.getLogs({ address: addr, fromBlock: effectiveFromBlock, toBlock, topics: [topic] });
       for (const log of logs) {
         try {
           const parsed = iface.parseLog(log);
@@ -2979,25 +3750,40 @@ var require_governance = __commonJS({
       if (!parsed) throw new Error("ProposalCreated event not found");
       const targets = parsed.args.targets.map(getAddress);
       const calldatas = parsed.args.calldatas.map((d) => typeof d === "string" ? d : "0x" + Buffer.from(d).toString("hex"));
-      const LibraryIface = new Interface(["function updateLibraryForSubDAO(address,string,string,uint256)", "function subdaoLibraryLatest(bytes32) view returns (string)"]);
+      const LibraryIface = new Interface(["function updateLibrary(address,string,string)"]);
       const PromptIface = new Interface(["function updatePromptByGovernance(string,string)"]);
-      const coder = AbiCoder.defaultAbiCoder ? AbiCoder.defaultAbiCoder() : new AbiCoder();
       const effects = [];
       for (let i = 0; i < calldatas.length; i++) {
         const data = calldatas[i];
         const sel = data.slice(0, 10);
         try {
-          const decoded = LibraryIface.decodeFunctionData("updateLibraryForSubDAO", data);
-          const [subdao, libraryId, newCid, promptCount] = decoded;
+          const decoded = LibraryIface.decodeFunctionData("updateLibrary", data);
+          const [dao, newCid, version] = decoded;
           let previousCID = null;
+          let previousVersion = null;
           try {
-            const reg = new Contract(targets[i], ["function subdaoLibraryLatest(bytes32) view returns (string)"], provider);
-            const key = keccak256(coder.encode(["address", "string"], [getAddress(subdao), String(libraryId)]));
-            const prev = await reg.subdaoLibraryLatest(key).catch(() => "");
-            previousCID = prev && prev.length ? String(prev) : null;
+            const reg = new Contract(
+              targets[i],
+              ["function libraryByDAO(address) view returns (tuple(string manifestCID,address lastUpdater,uint256 lastUpdated,string version,address forkedFromDAO,uint256 sxxxForkFee))"],
+              provider
+            );
+            const info = await reg.libraryByDAO(dao).catch(() => null);
+            if (info && typeof info.manifestCID === "string") {
+              previousCID = info.manifestCID || null;
+              previousVersion = info.version || null;
+            }
           } catch (_) {
           }
-          effects.push({ type: "libraryUpdate", index: i, target: targets[i], subdao: getAddress(subdao), libraryId: String(libraryId), previousCid: previousCID, newCid: String(newCid), promptCount: Number(promptCount) });
+          effects.push({
+            type: "libraryUpdateV4",
+            index: i,
+            target: targets[i],
+            dao: getAddress(dao),
+            previousCid: previousCID,
+            previousVersion,
+            newCid: String(newCid),
+            newVersion: String(version)
+          });
           continue;
         } catch (_) {
         }
@@ -3042,13 +3828,10 @@ var require_governance = __commonJS({
       } else {
         const govAddr = normaliseGovernor(governor);
         try {
-          const iface = new Interface(["function sxxxToken() view returns (address)"]);
-          const data = iface.encodeFunctionData("sxxxToken", []);
-          const ret = await provider.call({ to: govAddr, data });
-          const [tok] = AbiCoder.defaultAbiCoder().decode(["address"], ret);
-          addr = getAddress(tok);
+          const chain = await resolveVotesTokenChain({ provider, governor: govAddr });
+          addr = getAddress(chain.votingToken);
         } catch (err) {
-          throw new SageSDKError(CODES.NOT_FOUND, "failed to resolve governance token from governor", { cause: err });
+          throw new SageSDKError(CODES.NOT_FOUND, "failed to resolve votes token from governor", { cause: err });
         }
       }
       const user = getAddress(account);
@@ -3129,6 +3912,210 @@ var require_governance = __commonJS({
       const token = await g.sxxxToken();
       return buildDelegateTx({ token, delegatee: account });
     }
+    async function resolveVotesTokenChain({ provider, subdao, governor }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!subdao && !governor) throw new SageSDKError(CODES.INVALID_ARGS, "subdao or governor required");
+      let votingToken = null;
+      if (governor) {
+        const govAddr = normaliseGovernor(governor);
+        try {
+          const iTok = new Interface(["function token() view returns (address)"]);
+          const data = iTok.encodeFunctionData("token", []);
+          const ret = await provider.call({ to: govAddr, data });
+          if (ret && ret !== "0x") {
+            const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], ret);
+            votingToken = addr;
+          }
+        } catch (_) {
+        }
+        if (!votingToken) {
+          try {
+            const iGov = new Interface(["function sxxxToken() view returns (address)"]);
+            const d2 = iGov.encodeFunctionData("sxxxToken", []);
+            const r2 = await provider.call({ to: govAddr, data: d2 });
+            if (r2 && r2 !== "0x") {
+              const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], r2);
+              votingToken = addr;
+            }
+          } catch (_) {
+          }
+        }
+      }
+      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");
+      }
+      const votingTokenNorm = getAddress(votingToken);
+      let baseToken = votingTokenNorm;
+      let isWrapper = false;
+      try {
+        const wrapperIface = new Interface([
+          "function baseToken() view returns (address)",
+          "function dao() view returns (address)"
+        ]);
+        const [rawBase, rawDao] = await Promise.all([
+          provider.call({ to: votingTokenNorm, data: wrapperIface.encodeFunctionData("baseToken", []) }),
+          provider.call({ to: votingTokenNorm, data: wrapperIface.encodeFunctionData("dao", []) })
+        ]);
+        if (rawBase && rawBase !== "0x" && rawDao && rawDao !== "0x") {
+          const [decodedBase] = AbiCoder.defaultAbiCoder().decode(["address"], rawBase);
+          const [decodedDao] = AbiCoder.defaultAbiCoder().decode(["address"], rawDao);
+          const baseNorm = getAddress(decodedBase);
+          const daoNorm = getAddress(decodedDao);
+          if (!subdao || daoNorm === getAddress(subdao)) {
+            baseToken = baseNorm;
+            isWrapper = true;
+          }
+        }
+      } catch (_) {
+      }
+      return { votingToken: votingTokenNorm, baseToken, isWrapper };
+    }
+    async function describeVotesToken({ provider, subdao, governor }) {
+      const { votingToken, baseToken, isWrapper } = await resolveVotesTokenChain({ provider, subdao, governor });
+      let multiplierNFT = null;
+      let basis = null;
+      if (isWrapper) {
+        try {
+          const wrapper = new Contract(votingToken, ABI.MultipliedVotes, provider);
+          multiplierNFT = await wrapper.multiplierNFT().catch(() => null);
+          basis = await wrapper.BASIS().catch(() => null);
+        } catch (_) {
+        }
+      }
+      const votingNorm = getAddress(votingToken);
+      const baseNorm = getAddress(baseToken);
+      const multiplierNorm = multiplierNFT && /^0x[0-9a-fA-F]{40}$/.test(String(multiplierNFT)) ? getAddress(multiplierNFT) : null;
+      const basisBig = basis != null ? BigInt(String(basis)) : null;
+      let description;
+      if (!isWrapper) {
+        description = `Voting token = ERC20Votes at ${votingNorm}`;
+      } 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)}`;
+        }
+      }
+      return {
+        votingToken: votingNorm,
+        baseToken: baseNorm,
+        isWrapper,
+        multiplierNFT: multiplierNorm,
+        basis: basisBig,
+        description
+      };
+    }
+    async function getVotingStatus({ provider, subdao, 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 (!account) throw new SageSDKError(CODES.INVALID_ARGS, "account required");
+      const acct = getAddress(account);
+      let govAddr = null;
+      let subdaoAddr = null;
+      if (governor) {
+        govAddr = normaliseGovernor(governor);
+      }
+      if (subdao) {
+        subdaoAddr = getAddress(subdao);
+        if (!govAddr) {
+          try {
+            const sub = new Contract(subdaoAddr, ["function governor() view returns (address)"], provider);
+            govAddr = getAddress(await sub.governor());
+          } catch (_) {
+          }
+        }
+      }
+      if (!govAddr) throw new SageSDKError(CODES.INVALID_ARGS, "could not resolve governor address");
+      let threshold = null;
+      try {
+        const g = new Contract(govAddr, ABI.Governor, provider);
+        const t = await g.proposalThreshold();
+        threshold = BigInt(t.toString());
+      } 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)",
+        "function balanceOf(address) view returns (uint256)"
+      ];
+      let votingPower = null;
+      let delegate = null;
+      let tokenBalance = null;
+      try {
+        const votingC = new Contract(desc.votingToken, VotesABI, provider);
+        const vp = await votingC.getVotes(acct).catch(() => null);
+        if (vp != null) votingPower = BigInt(vp.toString());
+        const del = await votingC.delegates(acct).catch(() => null);
+        if (del && /^0x[0-9a-fA-F]{40}$/.test(String(del))) delegate = getAddress(del);
+        const bal = await votingC.balanceOf(acct).catch(() => null);
+        if (bal != null) tokenBalance = BigInt(bal.toString());
+      } 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,
+        multiplierNFT: desc.multiplierNFT,
+        basis: desc.basis,
+        threshold,
+        votingPower,
+        tokenBalance,
+        delegate,
+        canPropose,
+        tokenMismatch,
+        stakeTokenVotes,
+        stakeTokenDelegate,
+        stakeTokenBalance,
+        description: desc.description
+      };
+    }
     module2.exports = {
       getGovernorInfo,
       getProposal,
@@ -3160,52 +4147,28 @@ var require_governance = __commonJS({
        * - SubDAO.stakeToken() (when subdao provided)
        */
       resolveVotesToken: async function resolveVotesToken({ provider, subdao, 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 (governor) {
-          const govAddr = normaliseGovernor(governor);
-          try {
-            const iTok = new Interface(["function token() view returns (address)"]);
-            const data = iTok.encodeFunctionData("token", []);
-            const ret = await provider.call({ to: govAddr, data });
-            if (ret && ret !== "0x") {
-              const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], ret);
-              return getAddress(addr);
-            }
-          } catch (_) {
-          }
-          try {
-            const iGov = new Interface(["function sxxxToken() view returns (address)"]);
-            const d2 = iGov.encodeFunctionData("sxxxToken", []);
-            const r2 = await provider.call({ to: govAddr, data: d2 });
-            if (r2 && r2 !== "0x") {
-              const [addr] = AbiCoder.defaultAbiCoder().decode(["address"], r2);
-              return getAddress(addr);
-            }
-          } catch (_) {
-          }
-        }
-        if (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);
-              return getAddress(addr);
-            }
-          } catch (_) {
-          }
-        }
-        throw new SageSDKError(CODES.NOT_FOUND, "failed to resolve votes token");
+        const { votingToken } = await resolveVotesTokenChain({ provider, subdao, governor });
+        return votingToken;
       },
+      /**
+       * Resolve the IVotes token chain used for voting (wrapper + base token).
+       * See resolveVotesTokenChain() for details.
+       */
+      resolveVotesTokenChain,
+      /**
+       * Human-friendly description of the voting token wiring for a Governor/SubDAO.
+       */
+      describeVotesToken,
+      /**
+       * Get voting status for an account relative to a Governor/SubDAO.
+       */
+      getVotingStatus,
       /** Build a delegate(self) tx using the preferred votes token resolution path. */
       buildDelegateSelfPreferred: async function buildDelegateSelfPreferred({ provider, subdao, governor, account }) {
         if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
         if (!account) throw new SageSDKError(CODES.INVALID_ARGS, "account required");
-        const token = await this.resolveVotesToken({ provider, subdao, governor });
-        return buildDelegateTx({ token, delegatee: account });
+        const { baseToken } = await resolveVotesTokenChain({ provider, subdao, governor });
+        return buildDelegateTx({ token: baseToken, delegatee: account });
       },
       /**
        * Send a delegate(self) and verify votes at latest-1.
@@ -3214,15 +4177,15 @@ var require_governance = __commonJS({
       delegateSelfAndVerify: async function delegateSelfAndVerify({ provider, subdao, 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 token = await this.resolveVotesToken({ provider, subdao, governor });
-        const payload = buildDelegateTx({ token, delegatee: account });
+        const { votingToken, baseToken } = await resolveVotesTokenChain({ provider, subdao, governor });
+        const payload = buildDelegateTx({ token: baseToken, delegatee: account });
         let txHash = null;
         if (signer && typeof signer.sendTransaction === "function") {
           const tx = await signer.sendTransaction({ to: payload.to, data: payload.data, value: payload.value });
           txHash = tx?.hash || null;
           if (tx?.wait) await tx.wait();
         }
-        const votes = await getVotesLatestMinusOne({ provider, token, account });
+        const votes = await getVotesLatestMinusOne({ provider, token: votingToken, account });
         const ok = minVotes != null ? votes >= BigInt(minVotes) : votes > 0n;
         return { txHash, ok, votes, payload };
       },
@@ -3276,8 +4239,8 @@ var require_governance = __commonJS({
         }
         let votesOk = null;
         try {
-          const token = sxxx || await this.resolveVotesToken({ provider, governor });
-          const votes = await getVotesLatestMinusOne({ provider, token, account: user });
+          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;
         } catch (_) {
@@ -3294,7 +4257,7 @@ var require_governance = __commonJS({
       },
       /**
        * Compose propose readiness with optional execution readiness checks.
-       * execution?: { provider, registry, timelock, subdao, libraryId, manifestCID, promptCount }
+       * execution?: { provider, registry, timelock, subdao, manifestCID, version }
        */
       readinessToPropose: async function readinessToPropose({ provider, governor, proposer, execution = null }) {
         const gates = await this.ensureProposeGates({ provider, governor, proposer });
@@ -3303,12 +4266,11 @@ var require_governance = __commonJS({
         if (execution && execution.registry && execution.timelock && execution.subdao) {
           try {
             const library = require_library();
-            const { to, data } = library.buildUpdateLibraryForSubDAOTx({
+            const { to, data } = library.buildUpdateLibraryTx({
               registry: execution.registry,
               subdao: execution.subdao,
               manifestCID: execution.manifestCID || "",
-              promptCount: execution.promptCount || 0,
-              libraryId: execution.libraryId || "main"
+              version: execution.version || "1.0.0"
             });
             const sim = await library.simulateAsTimelock({ provider, registry: execution.registry, to, data, timelock: execution.timelock });
             executionReady = !!sim.ok;
@@ -3842,13 +4804,13 @@ var require_openzeppelin = __commonJS({
         return null;
       }
     }
-    async function getProposals({ provider, governor, fromBlock = 0, toBlock = "latest", pageSize = 5e3, abiResolver = null, selectorResolver = null, chainId = null }) {
+    async function getProposals({ provider, governor, fromBlock, toBlock = "latest", pageSize = 5e3, abiResolver = null, selectorResolver = null, chainId = null }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normaliseGovernor(governor);
       const iface = new Interface([Events.ProposalCreated]);
       const topic = iface.getEvent("ProposalCreated").topicHash;
       const latest = toBlock === "latest" ? await provider.getBlockNumber() : Number(toBlock);
-      const start = Number(fromBlock);
+      const start = fromBlock !== void 0 ? Number(fromBlock) : Math.max(0, latest - 5e4);
       const end = latest;
       const items = [];
       const resolvedChainId = await resolveChainId(provider, chainId);
@@ -3877,7 +4839,7 @@ var require_openzeppelin = __commonJS({
       }
       return { items, nextCursor: null };
     }
-    async function getTimelineOnchain({ provider, governor, id: id2, fromBlock = 0, toBlock = "latest" }) {
+    async function getTimelineOnchain({ provider, governor, id: id2, fromBlock, toBlock = "latest" }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normaliseGovernor(governor);
       const pid = typeof id2 === "bigint" ? id2 : String(id2).startsWith("0x") ? BigInt(id2) : BigInt(String(id2));
@@ -3888,7 +4850,8 @@ var require_openzeppelin = __commonJS({
         iface.getEvent("ProposalCanceled").topicHash
       ];
       const latest = toBlock === "latest" ? await provider.getBlockNumber() : Number(toBlock);
-      const logs = await provider.getLogs({ address: addr, fromBlock: Number(fromBlock), toBlock: latest, topics: [topics] });
+      const start = fromBlock !== void 0 ? Number(fromBlock) : Math.max(0, latest - 5e4);
+      const logs = await provider.getLogs({ address: addr, fromBlock: start, toBlock: latest, topics: [topics] });
       const out = [];
       for (const log of logs) {
         try {
@@ -4165,6 +5128,7 @@ var require_operations = __commonJS({
       cache = null,
       fromBlock = 0,
       helperAddress = null,
+      subgraphUrl = null,
       hints = {},
       chunkSizeBlocks = 1e4,
       lookBackBlocks = 2e3,
@@ -4178,6 +5142,27 @@ var require_operations = __commonJS({
         const cached = await cacheAdapter.load(govAddr, id2);
         if (cached) return cached;
       }
+      if (subgraphUrl) {
+        try {
+          const subgraph = require_subgraph2();
+          const sgProposal = await subgraph.getProposalById({ url: subgraphUrl, id: String(id2), governor: govAddr });
+          if (sgProposal && sgProposal.targets && sgProposal.targets.length > 0) {
+            const tuple2 = {
+              id: id2,
+              governor: govAddr,
+              targets: sgProposal.targets,
+              values: sgProposal.values || [],
+              calldatas: sgProposal.calldatas || [],
+              description: sgProposal.description || "",
+              descriptionHash: sgProposal.description ? keccak256(toUtf8Bytes(sgProposal.description)) : null,
+              createdBlock: sgProposal.createdAt || null
+            };
+            if (cacheAdapter) await cacheAdapter.save(govAddr, id2, tuple2);
+            return tuple2;
+          }
+        } catch (_) {
+        }
+      }
       if (helperAddress) {
         try {
           const helperAbi = [
@@ -4391,8 +5376,14 @@ var require_operations = __commonJS({
       ]);
       let resolvedSubDAO = subdao;
       if (!resolvedSubDAO) {
-        resolvedSubDAO = await governorContract.subDAO().catch(() => null);
-        if (resolvedSubDAO === ZeroAddress) resolvedSubDAO = null;
+        try {
+          const subDAOInterface = new Interface(["function subDAO() view returns (address)"]);
+          const subdaoContract = new Contract(govAddr, subDAOInterface, provider);
+          resolvedSubDAO = await subdaoContract.subDAO().catch(() => null);
+          if (resolvedSubDAO === ZeroAddress) resolvedSubDAO = null;
+        } catch {
+          resolvedSubDAO = null;
+        }
       }
       let mode = null;
       let eligible = null;
@@ -4467,10 +5458,11 @@ var require_operations = __commonJS({
       refresh = false,
       cache = null,
       includeTimeline = false,
-      helperAddress = null
+      helperAddress = null,
+      subgraphUrl = null
     }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
-      const tuple = await resolveProposalTuple({ provider, governor, proposalId, refresh, cache, helperAddress });
+      const tuple = await resolveProposalTuple({ provider, governor, proposalId, refresh, cache, helperAddress, subgraphUrl });
       let proposal = null;
       try {
         proposal = await governance.getProposal({ provider, governor: tuple.governor, id: tuple.id });
@@ -4808,8 +5800,6 @@ var require_factory = __commonJS({
         stableCreationFee,
         feeReceiver,
         allowStableFee,
-        stablePromptForkFee,
-        allowStablePromptForkFee,
         stableForkFee,
         allowStableForkFee,
         timelockMinDelay,
@@ -4833,8 +5823,6 @@ var require_factory = __commonJS({
           }
         })(),
         contract.allowStableFee().catch(() => null),
-        contract.stablePromptForkFee().catch(() => null),
-        contract.allowStablePromptForkFee().catch(() => null),
         contract.stableForkFee().catch(() => null),
         contract.allowStableForkFee().catch(() => null),
         contract.timelockMinDelay().catch(() => null),
@@ -4850,8 +5838,6 @@ var require_factory = __commonJS({
         stableCreationFee,
         feeReceiver: feeReceiver && feeReceiver !== "0x0000000000000000000000000000000000000000" ? getAddress(feeReceiver) : null,
         allowStableFee,
-        stablePromptForkFee,
-        allowStablePromptForkFee,
         stableForkFee,
         allowStableForkFee,
         timelockMinDelay,
@@ -5165,20 +6151,127 @@ var require_factory = __commonJS({
       }
     }
     module2.exports = {
-      getFactoryConfig,
-      getFactoryStats,
-      listSubDAOs,
-      listSubDAOsIndexed,
-      getSubDAORegistry,
-      listTemplates,
-      getTemplateDetails,
-      buildCreateSubDAOTx,
-      buildCreateSubDAOWithStableTx,
-      buildCreateSubDAOWithParamsTx,
-      buildCreateOperatorSubDAOWithStableTx,
-      buildCreateOperatorSubDAOWithStableAdvancedTx,
-      buildCreateForkedSubDAOTx,
-      buildCreateForkedSubDAOWithStableTx
+      getFactoryConfig,
+      getFactoryStats,
+      listSubDAOs,
+      listSubDAOsIndexed,
+      getSubDAORegistry,
+      listTemplates,
+      getTemplateDetails,
+      buildCreateSubDAOTx,
+      buildCreateSubDAOWithStableTx,
+      buildCreateSubDAOWithParamsTx,
+      buildCreateOperatorSubDAOWithStableTx,
+      buildCreateOperatorSubDAOWithStableAdvancedTx,
+      buildCreateForkedSubDAOTx,
+      buildCreateForkedSubDAOWithStableTx
+    };
+  }
+});
+
+// src/lineage/index.js
+var require_lineage = __commonJS({
+  "src/lineage/index.js"(exports2, module2) {
+    var { Contract, getAddress } = __require("ethers");
+    var { SageSDKError, CODES } = require_errors();
+    var LINEAGE_ABI = [
+      "function libraryByDAO(address) view returns (string manifestCID, address lastUpdater, uint256 lastUpdated, string version, address forkedFromDAO, uint256 sxxxForkFee)",
+      "function getLibraryForkFee(address) view returns (uint256)"
+    ];
+    var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+    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 getParentLibrary({ provider, registry, subdao }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!registry) throw new SageSDKError(CODES.INVALID_ARGS, "registry required");
+      if (!subdao) throw new SageSDKError(CODES.INVALID_ARGS, "subdao required");
+      try {
+        const contract = new Contract(normalise(registry, "registry"), LINEAGE_ABI, provider);
+        const info = await contract.libraryByDAO(normalise(subdao, "subdao"));
+        const parent = info.forkedFromDAO;
+        if (!parent || parent === ZERO_ADDRESS) {
+          return null;
+        }
+        return getAddress(parent).toLowerCase();
+      } catch (err) {
+        throw new SageSDKError(CODES.CONTRACT_ERROR, "Failed to fetch parent library", { cause: err });
+      }
+    }
+    async function getLineageChain({ provider, registry, subdao }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!registry) throw new SageSDKError(CODES.INVALID_ARGS, "registry required");
+      if (!subdao) throw new SageSDKError(CODES.INVALID_ARGS, "subdao required");
+      try {
+        const contract = new Contract(normalise(registry, "registry"), LINEAGE_ABI, provider);
+        const chain = [];
+        let current = normalise(subdao, "subdao");
+        const MAX_DEPTH = 100;
+        let iterations = 0;
+        while (current && iterations < MAX_DEPTH) {
+          chain.unshift(getAddress(current).toLowerCase());
+          const info = await contract.libraryByDAO(current);
+          const parent = info.forkedFromDAO;
+          if (!parent || parent === ZERO_ADDRESS) {
+            break;
+          }
+          current = parent;
+          iterations++;
+        }
+        return {
+          chain,
+          depth: chain.length - 1,
+          root: chain[0]
+        };
+      } catch (err) {
+        throw new SageSDKError(CODES.CONTRACT_ERROR, "Failed to fetch lineage chain", { cause: err });
+      }
+    }
+    async function isFork({ provider, registry, subdao }) {
+      const parent = await getParentLibrary({ provider, registry, subdao });
+      return parent !== null;
+    }
+    async function getLibraryForkFee({ provider, registry, subdao }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!registry) throw new SageSDKError(CODES.INVALID_ARGS, "registry required");
+      if (!subdao) throw new SageSDKError(CODES.INVALID_ARGS, "subdao required");
+      try {
+        const contract = new Contract(normalise(registry, "registry"), LINEAGE_ABI, provider);
+        const fee = await contract.getLibraryForkFee(normalise(subdao, "subdao"));
+        return BigInt(fee.toString());
+      } catch (err) {
+        throw new SageSDKError(CODES.CONTRACT_ERROR, "Failed to fetch library fork fee", { cause: err });
+      }
+    }
+    async function getLibraryInfo({ provider, registry, subdao }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      if (!registry) throw new SageSDKError(CODES.INVALID_ARGS, "registry required");
+      if (!subdao) throw new SageSDKError(CODES.INVALID_ARGS, "subdao required");
+      try {
+        const contract = new Contract(normalise(registry, "registry"), LINEAGE_ABI, provider);
+        const info = await contract.libraryByDAO(normalise(subdao, "subdao"));
+        const parent = info.forkedFromDAO;
+        return {
+          parentDAO: !parent || parent === ZERO_ADDRESS ? null : getAddress(parent).toLowerCase(),
+          forkFee: BigInt(info.sxxxForkFee.toString()),
+          manifestCID: info.manifestCID,
+          version: info.version
+        };
+      } catch (err) {
+        throw new SageSDKError(CODES.CONTRACT_ERROR, "Failed to fetch library info", { cause: err });
+      }
+    }
+    module2.exports = {
+      getParentLibrary,
+      getLineageChain,
+      isFork,
+      getLibraryForkFee,
+      getLibraryInfo
     };
   }
 });
@@ -5855,7 +6948,6 @@ var require_ipns = __commonJS({
             headers["X-Wallet-Address"] = auth.address;
             headers["X-Wallet-Signature"] = auth.signature;
             headers["X-Wallet-Nonce"] = auth.nonce;
-            headers["X-Wallet-Message"] = auth.message;
           }
           return { headers, auth };
         }
@@ -5877,8 +6969,7 @@ var require_ipns = __commonJS({
             ...extraHeaders,
             "X-Wallet-Address": auth.address,
             "X-Wallet-Signature": auth.signature,
-            "X-Wallet-Nonce": auth.nonce,
-            "X-Wallet-Message": auth.message
+            "X-Wallet-Nonce": auth.nonce
           };
           return { headers, auth };
         }
@@ -6515,8 +7606,34 @@ var require_time = __commonJS({
 var require_treasury = __commonJS({
   "src/treasury/index.js"(exports2, module2) {
     var { Contract, Interface, getAddress } = __require("ethers");
-    var ABI = require_abi();
     var { SageSDKError, CODES } = require_errors();
+    var SAGE_TREASURY_ABI = [
+      // Aggregated views
+      "function totalReserves() view returns (uint256)",
+      "function totalPOL() view returns (uint256)",
+      "function totalDebt() view returns (uint256)",
+      // Canonical liquidity config
+      "function canonicalPool() view returns (address)",
+      "function routerOrVault() view returns (address)",
+      // Withdrawal rate limits
+      "function maxWithdrawalRate() view returns (uint256)",
+      "function emergencyWithdrawalLimit() view returns (uint256)",
+      // Reserve tokens
+      "function getReserveTokens() view returns (address[])",
+      "function getReserve(address token) view returns (tuple(uint256 amount, uint256 value, bool isLP, bool isActive))",
+      // Withdrawal queue
+      "function nextWithdrawalId() view returns (uint256)",
+      "function pendingWithdrawals(uint256 id) view returns (tuple(bool exists, address token, address recipient, uint256 amount, uint256 value, address requester, uint256 balanceBefore, uint256 recipientBalanceBefore, uint256 depositSnapshot, bool isLP, bool isEmergency))",
+      "function withdraw(address token, uint256 amount, address recipient)",
+      "function confirmWithdrawal(uint256 id)",
+      "function cancelWithdrawal(uint256 id)",
+      // Manual price overrides
+      "function manualPrices(address token) view returns (tuple(uint256 price, uint256 expiresAt, bool active))",
+      "function setPriceOverride(address token, uint256 price, uint256 ttlSeconds)",
+      "function clearPriceOverride(address token)",
+      // Events
+      "event WithdrawalScheduled(uint256 indexed id, address indexed token, address indexed recipient, uint256 amount)"
+    ];
     var LiquidityEvents = new Interface([
       "event CanonicalLiquidityUpdated(address indexed pool, address indexed routerOrVault)",
       "event LiquidityAddPlanned(address indexed subdao, address indexed pool, address sxxxToken, address stableToken, uint256 sxxxAmount, uint256 stableAmount, address lpRecipient)",
@@ -6561,7 +7678,7 @@ var require_treasury = __commonJS({
     async function getTreasuryInfo({ provider, treasury }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury, "treasury");
-      const contract = new Contract(addr, ABI.SageTreasury, provider);
+      const contract = new Contract(addr, SAGE_TREASURY_ABI, provider);
       const [totalReserves, totalPOL, totalDebt, canonicalPool, routerOrVault, maxWithdrawalRate, emergencyWithdrawalLimit] = await Promise.all([
         contract.totalReserves().catch(() => 0n),
         contract.totalPOL().catch(() => 0n),
@@ -6585,7 +7702,7 @@ var require_treasury = __commonJS({
     async function getPendingWithdrawals({ provider, treasury, ids, limit = 50 }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury, "treasury");
-      const contract = new Contract(addr, ABI.SageTreasury, provider);
+      const contract = new Contract(addr, SAGE_TREASURY_ABI, provider);
       let idList = ids;
       if (!Array.isArray(idList)) {
         const nextId = await contract.nextWithdrawalId().catch(() => 0n);
@@ -6617,14 +7734,14 @@ var require_treasury = __commonJS({
     async function getReserveTokens({ provider, treasury }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury, "treasury");
-      const contract = new Contract(addr, ABI.SageTreasury, provider);
+      const contract = new Contract(addr, SAGE_TREASURY_ABI, provider);
       const tokens = await contract.getReserveTokens().catch(() => []);
       return tokens.map((token) => getAddress(token));
     }
     async function getReserves({ provider, treasury, tokens, fetchMetadata = true }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury, "treasury");
-      const contract = new Contract(addr, ABI.SageTreasury, provider);
+      const contract = new Contract(addr, SAGE_TREASURY_ABI, provider);
       const tokenList = Array.isArray(tokens) && tokens.length ? tokens.map((token) => getAddress(token)) : await contract.getReserveTokens().catch(() => []);
       const reserves = [];
       for (const token of tokenList) {
@@ -6654,7 +7771,7 @@ var require_treasury = __commonJS({
     async function getManualPriceOverrides({ provider, treasury, tokens }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury, "treasury");
-      const contract = new Contract(addr, ABI.SageTreasury, provider);
+      const contract = new Contract(addr, SAGE_TREASURY_ABI, provider);
       const tokenList = Array.isArray(tokens) && tokens.length ? tokens.map((token) => getAddress(token)) : await contract.getReserveTokens().catch(() => []);
       const overrides = [];
       for (const token of tokenList) {
@@ -6759,7 +7876,7 @@ var require_treasury = __commonJS({
     async function getLPContribution({ provider, treasury, subdao, token }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(treasury, "treasury");
-      const c = new Contract(addr, ABI.SageTreasury, provider);
+      const c = new Contract(addr, SAGE_TREASURY_ABI, provider);
       const amount = await c.lpContributions(normalise(subdao, "subdao"), normalise(token, "token")).catch(() => 0n);
       return amount;
     }
@@ -6801,7 +7918,7 @@ var require_treasury = __commonJS({
     function createWriteContract({ signer, treasury }) {
       if (!signer) throw new SageSDKError(CODES.INVALID_ARGS, "signer required");
       const addr = normalise(treasury, "treasury");
-      return new Contract(addr, ABI.SageTreasury, signer);
+      return new Contract(addr, SAGE_TREASURY_ABI, signer);
     }
     async function waitForReceipt({ signer, tx, waitMs }) {
       const provider = signer.provider;
@@ -7097,10 +8214,787 @@ var require_bounty = __commonJS({
       return { governor, proposalCall };
     }
     module2.exports = {
-      configureWinnerMode,
-      fundFromTreasury,
-      approveWinner,
-      proposeApproveWinner
+      configureWinnerMode,
+      fundFromTreasury,
+      approveWinner,
+      proposeApproveWinner
+    };
+  }
+});
+
+// src/contributions/index.js
+var require_contributions = __commonJS({
+  "src/contributions/index.js"(exports2, module2) {
+    var { getAddress, isAddress } = __require("ethers");
+    var subgraph = require_subgraph();
+    var GovernanceModel = {
+      TOKEN_VOTING: "TOKEN_VOTING",
+      COUNCIL: "COUNCIL",
+      OPERATOR: "OPERATOR",
+      DIRECT: "DIRECT"
+    };
+    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;
+    }
+    function detectGovernanceModel(subdaoInfo) {
+      if (!subdaoInfo) return GovernanceModel.DIRECT;
+      const playbook = subdaoInfo.playbook;
+      if (playbook) {
+        if (playbook === "council-closed" || playbook === "council-drafts") {
+          return GovernanceModel.COUNCIL;
+        }
+        if (playbook === "community") {
+          return GovernanceModel.TOKEN_VOTING;
+        }
+      }
+      const governanceKind = subdaoInfo.governanceKind;
+      if (governanceKind === 0) {
+        return GovernanceModel.OPERATOR;
+      }
+      if (governanceKind === 1) {
+        const proposalAccess = subdaoInfo.proposalAccess;
+        if (proposalAccess === 0) {
+          return GovernanceModel.COUNCIL;
+        }
+        return GovernanceModel.TOKEN_VOTING;
+      }
+      return GovernanceModel.TOKEN_VOTING;
+    }
+    async function listContributions({
+      url,
+      subdao,
+      promptKey,
+      contributor,
+      fromBounty,
+      first = 50,
+      skip = 0,
+      orderBy = "updatedAt",
+      orderDirection = "desc"
+    }) {
+      if (!url) throw new Error("subgraph url required");
+      const filters = [];
+      if (subdao) {
+        const addr = safeGetAddress(subdao);
+        if (!addr) throw new Error("invalid subdao address");
+        filters.push(`dao: "${addr.toLowerCase()}"`);
+      }
+      if (promptKey) {
+        filters.push(`promptKey: "${String(promptKey)}"`);
+      }
+      if (contributor) {
+        const addr = safeGetAddress(contributor);
+        if (!addr) throw new Error("invalid contributor address");
+        filters.push(`contributor: "${addr.toLowerCase()}"`);
+      }
+      if (fromBounty !== void 0) {
+        filters.push(`fromBounty: ${Boolean(fromBounty)}`);
+      }
+      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!, $skip: Int!) {
+      promptContributions(
+        ${where}
+        first: $first
+        skip: $skip
+        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: Math.min(Math.max(1, Number(first || 50)), 100),
+        skip: Number(skip || 0)
+      });
+      return mapSafe(data?.promptContributions, mapContribution);
+    }
+    async function getByPrompt({ url, subdao, promptKey }) {
+      if (!url) throw new Error("subgraph url required");
+      if (!subdao) throw new Error("subdao required");
+      if (!promptKey) throw new Error("promptKey required");
+      const contributions = await listContributions({
+        url,
+        subdao,
+        promptKey,
+        first: 100
+      });
+      const aggregates = computeAggregates(contributions);
+      return { contributions, aggregates };
+    }
+    async function getById({ url, id: id2 }) {
+      if (!url) throw new Error("subgraph url required");
+      if (!id2) throw new Error("id required");
+      const doc = `
+    query($id: ID!) {
+      promptContribution(id: $id) {
+        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, { id: String(id2) });
+      const row = data?.promptContribution;
+      if (!row) return null;
+      return mapContribution(row);
+    }
+    function mapContribution(row) {
+      const dao = safeGetAddress(row.dao);
+      const contributor = safeGetAddress(row.contributor);
+      if (!dao) return null;
+      let governanceModel = GovernanceModel.DIRECT;
+      if (row.proposalId != null) {
+        governanceModel = GovernanceModel.TOKEN_VOTING;
+      } else if (row.fromBounty) {
+        governanceModel = GovernanceModel.DIRECT;
+      }
+      return {
+        id: String(row.id),
+        dao,
+        daoName: null,
+        // Enriched separately if needed
+        promptKey: String(row.promptKey),
+        contributor: contributor || "0x0000000000000000000000000000000000000000",
+        cid: String(row.cid),
+        timestamp: Number(row.updatedAt || 0),
+        createdAt: Number(row.createdAt || 0),
+        updatedAt: Number(row.updatedAt || 0),
+        transactionHash: row.transactionHash || null,
+        // Governance context
+        governanceModel,
+        proposalId: row.proposalId != null ? BigInt(String(row.proposalId)) : null,
+        forVotes: row.forVotes != null ? BigInt(String(row.forVotes)) : null,
+        againstVotes: row.againstVotes != null ? BigInt(String(row.againstVotes)) : null,
+        abstainVotes: row.abstainVotes != null ? BigInt(String(row.abstainVotes)) : null,
+        uniqueVoters: row.uniqueVoters != null ? Number(row.uniqueVoters) : null,
+        quorum: row.quorum != null ? BigInt(String(row.quorum)) : null,
+        // Bounty context
+        fromBounty: Boolean(row.fromBounty),
+        bountyId: row.bountyId != null ? BigInt(String(row.bountyId)) : null,
+        // Badge context
+        badgeId: row.badgeId != null ? BigInt(String(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: 0n,
+          totalAgainstVotes: 0n,
+          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) totalForVotes += c.forVotes;
+        if (c.againstVotes != null) totalAgainstVotes += c.againstVotes;
+        if (c.uniqueVoters != null) {
+          voterCountSum += c.uniqueVoters;
+          voterCountN++;
+        }
+        if (c.badgeId != null) badgeCount++;
+      }
+      return {
+        totalContributions: contributions.length,
+        uniqueContributors: contributorSet.size,
+        bountyOriginated,
+        governanceOriginated,
+        totalForVotes,
+        totalAgainstVotes,
+        averageVoterCount: voterCountN > 0 ? Math.round(voterCountSum / voterCountN) : 0,
+        badgeCount
+      };
+    }
+    function getGovernanceQuality(contribution, context = {}) {
+      if (!contribution) {
+        return {
+          model: GovernanceModel.DIRECT,
+          decentralization: 0,
+          consensus: 0,
+          raw: {}
+        };
+      }
+      const model = contribution.governanceModel || GovernanceModel.DIRECT;
+      switch (model) {
+        case GovernanceModel.TOKEN_VOTING:
+          return computeTokenVotingQuality(contribution, context);
+        case GovernanceModel.COUNCIL:
+          return computeCouncilQuality(contribution, context);
+        case GovernanceModel.OPERATOR:
+          return computeOperatorQuality(contribution, context);
+        case GovernanceModel.DIRECT:
+        default:
+          return {
+            model: GovernanceModel.DIRECT,
+            decentralization: 0,
+            consensus: 1,
+            // Direct = full consensus (single decision maker)
+            raw: {
+              contributor: contribution.contributor
+            }
+          };
+      }
+    }
+    function computeTokenVotingQuality(contribution, context) {
+      const forVotes = contribution.forVotes || 0n;
+      const againstVotes = contribution.againstVotes || 0n;
+      const abstainVotes = contribution.abstainVotes || 0n;
+      const totalVotes = forVotes + againstVotes + abstainVotes;
+      const uniqueVoters = contribution.uniqueVoters || 0;
+      const quorum = contribution.quorum || null;
+      const totalHolders = context.totalHolders || null;
+      let decentralization = 0;
+      if (totalHolders && totalHolders > 0 && uniqueVoters > 0) {
+        decentralization = Math.min(1, uniqueVoters / totalHolders);
+      } else if (uniqueVoters > 0) {
+        decentralization = Math.min(1, Math.log10(uniqueVoters + 1) / 3);
+      }
+      let consensus = 0;
+      if (totalVotes > 0n) {
+        consensus = Number(forVotes * 10000n / totalVotes) / 1e4;
+      }
+      let quorumMet = null;
+      if (quorum != null && quorum > 0n) {
+        quorumMet = totalVotes >= quorum;
+      }
+      return {
+        model: GovernanceModel.TOKEN_VOTING,
+        decentralization,
+        consensus,
+        raw: {
+          forVotes,
+          againstVotes,
+          abstainVotes,
+          totalVotes,
+          uniqueVoters,
+          quorum,
+          quorumMet,
+          proposalId: contribution.proposalId
+        }
+      };
+    }
+    function computeCouncilQuality(contribution, context) {
+      const signerCount = contribution.signerCount || context.signerCount || 0;
+      const threshold = contribution.threshold || context.threshold || 0;
+      const totalCouncilMembers = context.totalCouncilMembers || threshold;
+      let decentralization = 0;
+      if (totalCouncilMembers > 0 && signerCount > 0) {
+        decentralization = Math.min(1, signerCount / totalCouncilMembers);
+      }
+      let consensus = 0;
+      if (threshold > 0) {
+        consensus = Math.min(1, signerCount / threshold);
+      }
+      return {
+        model: GovernanceModel.COUNCIL,
+        decentralization,
+        consensus,
+        raw: {
+          signerCount,
+          threshold,
+          totalCouncilMembers,
+          signers: contribution.signers || []
+        }
+      };
+    }
+    function computeOperatorQuality(contribution, context) {
+      return {
+        model: GovernanceModel.OPERATOR,
+        decentralization: 0,
+        // Single operator = not decentralized
+        consensus: 1,
+        // Operator decision = full "consensus"
+        raw: {
+          operator: contribution.operator || contribution.contributor,
+          operatorRole: contribution.operatorRole || context.operatorRole || null
+        }
+      };
+    }
+    function enrichWithGovernanceModel(contribution, subdaoInfo) {
+      if (!contribution) return contribution;
+      const model = detectGovernanceModel(subdaoInfo);
+      return {
+        ...contribution,
+        governanceModel: model,
+        daoName: subdaoInfo?.name || null
+      };
+    }
+    async function getByContributor({ url, contributor, first = 50, skip = 0 }) {
+      if (!url) throw new Error("subgraph url required");
+      if (!contributor) throw new Error("contributor required");
+      return listContributions({ url, contributor, first, skip });
+    }
+    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: Math.min(Math.max(1, Number(first || 50)), 100)
+      });
+      return mapSafe(data?.soulboundBadges, (row) => {
+        const contract = safeGetAddress(row.contract);
+        const recipient2 = safeGetAddress(row.recipient);
+        if (!contract || !recipient2) return null;
+        return {
+          id: String(row.id),
+          contract,
+          badgeId: BigInt(String(row.badgeId || "0")),
+          recipient: recipient2,
+          evidenceURI: row.evidenceURI || null,
+          blockNumber: Number(row.blockNumber || 0),
+          blockTimestamp: Number(row.blockTimestamp || 0),
+          transactionHash: row.transactionHash || null
+        };
+      });
+    }
+    module2.exports = {
+      // Constants
+      GovernanceModel,
+      // Main queries
+      listContributions,
+      getByPrompt,
+      getById,
+      getByContributor,
+      getBadgesByRecipient,
+      // Governance quality helpers
+      getGovernanceQuality,
+      enrichWithGovernanceModel,
+      detectGovernanceModel,
+      // Aggregation helpers
+      computeAggregates
+    };
+  }
+});
+
+// src/votingMultiplier/index.js
+var require_votingMultiplier = __commonJS({
+  "src/votingMultiplier/index.js"(exports2, module2) {
+    var { Contract, Interface, getAddress } = __require("ethers");
+    var ABI = require_abi();
+    var { SageSDKError, CODES } = require_errors();
+    function normaliseAddress(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 });
+      }
+    }
+    function toBigInt(value, label) {
+      if (value === void 0 || value === null) {
+        throw new SageSDKError(CODES.INVALID_ARGS, `${label} required`);
+      }
+      try {
+        return BigInt(value.toString());
+      } catch (err) {
+        throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
+      }
+    }
+    function getNftContract(provider, nft) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const addr = normaliseAddress(nft, "nft");
+      return new Contract(addr, ABI.VotingMultiplierNFT, provider);
+    }
+    function getWrapperContract(provider, wrapper) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const addr = normaliseAddress(wrapper, "wrapper");
+      return new Contract(addr, ABI.MultipliedVotes, provider);
+    }
+    async function getTier({ provider, nft, tierId }) {
+      const c = getNftContract(provider, nft);
+      const id2 = toBigInt(tierId, "tierId");
+      let tier;
+      if (typeof c.getTier === "function") {
+        tier = await c.getTier(id2);
+      } else {
+        tier = await c.tiers(id2);
+      }
+      const name = String(tier.name ?? tier[0]);
+      const multiplier = BigInt((tier.multiplier ?? tier[1]).toString());
+      const maxSupply = BigInt((tier.maxSupply ?? tier[2]).toString());
+      const minted = BigInt((tier.minted ?? tier[3]).toString());
+      const price = BigInt((tier.price ?? tier[4]).toString());
+      const dao = getAddress(tier.dao ?? tier[5]);
+      return { name, multiplier, maxSupply, minted, price, dao };
+    }
+    async function getTierCount({ provider, nft }) {
+      const c = getNftContract(provider, nft);
+      const count = await c.tierCount();
+      return BigInt(count.toString());
+    }
+    function buildCreateTierTx({ nft, dao, name, multiplier, maxSupply, price }) {
+      const addr = normaliseAddress(nft, "nft");
+      const iface = new Interface(ABI.VotingMultiplierNFT);
+      const data = iface.encodeFunctionData("createTier", [
+        normaliseAddress(dao, "dao"),
+        String(name ?? ""),
+        toBigInt(multiplier, "multiplier"),
+        toBigInt(maxSupply, "maxSupply"),
+        toBigInt(price, "price")
+      ]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildMintTx({ nft, to, tierId, uri }) {
+      const addr = normaliseAddress(nft, "nft");
+      const iface = new Interface(ABI.VotingMultiplierNFT);
+      const data = iface.encodeFunctionData("mint", [
+        normaliseAddress(to, "to"),
+        toBigInt(tierId, "tierId"),
+        String(uri ?? "")
+      ]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildPublicMintTx({ nft, tierId, uri, value }) {
+      const addr = normaliseAddress(nft, "nft");
+      const iface = new Interface(ABI.VotingMultiplierNFT);
+      const data = iface.encodeFunctionData("publicMint", [
+        toBigInt(tierId, "tierId"),
+        String(uri ?? "")
+      ]);
+      return { to: addr, data, value: toBigInt(value ?? 0n, "value") };
+    }
+    async function getMultiplier({ provider, nft, account, dao }) {
+      const c = getNftContract(provider, nft);
+      const res = await c.getMultiplier(normaliseAddress(account, "account"), normaliseAddress(dao, "dao"));
+      return BigInt(res.toString());
+    }
+    async function getPastMultiplier({ provider, nft, account, dao, timepoint }) {
+      const c = getNftContract(provider, nft);
+      const res = await c.getPastMultiplier(
+        normaliseAddress(account, "account"),
+        normaliseAddress(dao, "dao"),
+        toBigInt(timepoint, "timepoint")
+      );
+      return BigInt(res.toString());
+    }
+    async function getTokenMultiplier({ provider, nft, tokenId }) {
+      const c = getNftContract(provider, nft);
+      const res = await c.getTokenMultiplier(toBigInt(tokenId, "tokenId"));
+      return BigInt(res.toString());
+    }
+    async function getTokenDAO({ provider, nft, tokenId }) {
+      const c = getNftContract(provider, nft);
+      const res = await c.getTokenDAO(toBigInt(tokenId, "tokenId"));
+      return getAddress(res);
+    }
+    async function getTokenInfo({ provider, nft, tokenId }) {
+      const c = getNftContract(provider, nft);
+      const id2 = toBigInt(tokenId, "tokenId");
+      const info = await c.getTokenInfo(id2);
+      const owner = getAddress(info.owner ?? info[0]);
+      const tierId = BigInt((info.tierId ?? info[1]).toString());
+      const multiplier = BigInt((info.multiplier ?? info[2]).toString());
+      const uri = String(info.uri ?? info[3]);
+      return { owner, tierId, multiplier, uri };
+    }
+    async function getVotes({ provider, wrapper, account }) {
+      const c = getWrapperContract(provider, wrapper);
+      const res = await c.getVotes(normaliseAddress(account, "account"));
+      return BigInt(res.toString());
+    }
+    async function getPastVotes({ provider, wrapper, account, timepoint }) {
+      const c = getWrapperContract(provider, wrapper);
+      const res = await c.getPastVotes(
+        normaliseAddress(account, "account"),
+        toBigInt(timepoint, "timepoint")
+      );
+      return BigInt(res.toString());
+    }
+    async function getVotingBreakdown({ provider, wrapper, account }) {
+      const c = getWrapperContract(provider, wrapper);
+      const [baseVotes, multiplier, effectiveVotes] = await c.getVotingBreakdown(normaliseAddress(account, "account"));
+      return {
+        baseVotes: BigInt(baseVotes.toString()),
+        multiplier: BigInt(multiplier.toString()),
+        effectiveVotes: BigInt(effectiveVotes.toString())
+      };
+    }
+    async function getPastVotingBreakdown({ provider, wrapper, account, timepoint }) {
+      const c = getWrapperContract(provider, wrapper);
+      const [baseVotes, multiplier, effectiveVotes] = await c.getPastVotingBreakdown(
+        normaliseAddress(account, "account"),
+        toBigInt(timepoint, "timepoint")
+      );
+      return {
+        baseVotes: BigInt(baseVotes.toString()),
+        multiplier: BigInt(multiplier.toString()),
+        effectiveVotes: BigInt(effectiveVotes.toString())
+      };
+    }
+    async function hasMultiplierBonus({ provider, wrapper, account }) {
+      const c = getWrapperContract(provider, wrapper);
+      const res = await c.hasMultiplierBonus(normaliseAddress(account, "account"));
+      return !!res;
+    }
+    module2.exports = {
+      // Tier management
+      getTier,
+      getTierCount,
+      buildCreateTierTx,
+      // Minting
+      buildMintTx,
+      buildPublicMintTx,
+      // Multiplier queries
+      getMultiplier,
+      getPastMultiplier,
+      getTokenMultiplier,
+      getTokenDAO,
+      getTokenInfo,
+      // Wrapper queries
+      getVotes,
+      getPastVotes,
+      getVotingBreakdown,
+      getPastVotingBreakdown,
+      hasMultiplierBonus
+    };
+  }
+});
+
+// src/auction/index.js
+var require_auction = __commonJS({
+  "src/auction/index.js"(exports2, module2) {
+    var { Contract, Interface, getAddress } = __require("ethers");
+    var ABI = require_abi();
+    var { SageSDKError, CODES } = require_errors();
+    function normaliseAddress(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 });
+      }
+    }
+    function toBigInt(value, label) {
+      if (value === void 0 || value === null) {
+        throw new SageSDKError(CODES.INVALID_ARGS, `${label} required`);
+      }
+      try {
+        return BigInt(value.toString());
+      } catch (err) {
+        throw new SageSDKError(CODES.INVALID_ARGS, `invalid ${label}`, { cause: err });
+      }
+    }
+    function getAuctionContract(provider, auctionHouse) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      return new Contract(addr, ABI.SageAuctionHouse, provider);
+    }
+    async function getAuction({ provider, auctionHouse }) {
+      const c = getAuctionContract(provider, auctionHouse);
+      const res = await c.auction();
+      const nftId = BigInt(res.nftId.toString());
+      const amount = BigInt(res.amount.toString());
+      const startTime = BigInt(res.startTime.toString());
+      const endTime = BigInt(res.endTime.toString());
+      const bidder = getAddress(res.bidder);
+      const settled = !!res.settled;
+      return { nftId, amount, startTime, endTime, bidder, settled };
+    }
+    async function getConfig({ provider, auctionHouse }) {
+      const c = getAuctionContract(provider, auctionHouse);
+      const [nft, treasury, weth, timeBuffer, reservePrice, minBidIncrementPercentage, duration, mintTierId, defaultTokenURI, paused, owner] = await Promise.all([
+        c.nft(),
+        c.treasury(),
+        c.weth(),
+        c.timeBuffer(),
+        c.reservePrice(),
+        c.minBidIncrementPercentage(),
+        c.duration(),
+        c.mintTierId(),
+        c.defaultTokenURI(),
+        c.paused(),
+        c.owner()
+      ]);
+      return {
+        nft: getAddress(nft),
+        treasury: getAddress(treasury),
+        weth: getAddress(weth),
+        timeBuffer: BigInt(timeBuffer.toString()),
+        reservePrice: BigInt(reservePrice.toString()),
+        minBidIncrementPercentage: BigInt(minBidIncrementPercentage.toString()),
+        duration: BigInt(duration.toString()),
+        mintTierId: BigInt(mintTierId.toString()),
+        defaultTokenURI: String(defaultTokenURI),
+        paused: !!paused,
+        owner: getAddress(owner)
+      };
+    }
+    function buildCreateBidTx({ auctionHouse, nftId, value }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("createBid", [toBigInt(nftId, "nftId")]);
+      return { to: addr, data, value: toBigInt(value, "value") };
+    }
+    function buildSettleAndCreateTx({ auctionHouse }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("settleCurrentAndCreateNewAuction", []);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSettleTx({ auctionHouse }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("settleAuction", []);
+      return { to: addr, data, value: 0n };
+    }
+    function buildCreateAuctionTx({ auctionHouse }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("createAuction", []);
+      return { to: addr, data, value: 0n };
+    }
+    function buildPauseTx({ auctionHouse }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("pause", []);
+      return { to: addr, data, value: 0n };
+    }
+    function buildUnpauseTx({ auctionHouse }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("unpause", []);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSetTimeBufferTx({ auctionHouse, timeBuffer }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("setTimeBuffer", [toBigInt(timeBuffer, "timeBuffer")]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSetReservePriceTx({ auctionHouse, reservePrice }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("setReservePrice", [toBigInt(reservePrice, "reservePrice")]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSetMinBidIncrementTx({ auctionHouse, percentage }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("setMinBidIncrementPercentage", [toBigInt(percentage, "percentage")]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSetDurationTx({ auctionHouse, duration }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("setDuration", [toBigInt(duration, "duration")]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSetMintTierIdTx({ auctionHouse, tierId }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("setMintTierId", [toBigInt(tierId, "tierId")]);
+      return { to: addr, data, value: 0n };
+    }
+    function buildSetDefaultTokenURITx({ auctionHouse, uri }) {
+      const addr = normaliseAddress(auctionHouse, "auctionHouse");
+      const iface = new Interface(ABI.SageAuctionHouse);
+      const data = iface.encodeFunctionData("setDefaultTokenURI", [String(uri ?? "")]);
+      return { to: addr, data, value: 0n };
+    }
+    module2.exports = {
+      getAuction,
+      getConfig,
+      buildCreateBidTx,
+      buildSettleAndCreateTx,
+      buildSettleTx,
+      buildCreateAuctionTx,
+      buildPauseTx,
+      buildUnpauseTx,
+      buildSetTimeBufferTx,
+      buildSetReservePriceTx,
+      buildSetMinBidIncrementTx,
+      buildSetDurationTx,
+      buildSetMintTierIdTx,
+      buildSetDefaultTokenURITx
     };
   }
 });
@@ -9910,6 +11804,885 @@ var require_client2 = __commonJS({
   }
 });
 
+// src/clients/discovery-client.js
+var require_discovery_client = __commonJS({
+  "src/clients/discovery-client.js"(exports2, module2) {
+    var DiscoveryClient = class {
+      /**
+       * @param {string} baseUrl - Base URL of the discovery API
+       * @param {object} [options] - Client options
+       * @param {number} [options.timeout=10000] - Request timeout in milliseconds
+       * @param {Record<string, string>} [options.headers] - Custom headers
+       */
+      constructor(baseUrl, options = {}) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.timeout = options.timeout || 1e4;
+        this.headers = options.headers || {};
+      }
+      /**
+       * Search prompts with keyword matching and trend ranking
+       * @param {string} query - Search query
+       * @param {object} [options] - Search options
+       * @param {string} [options.category] - Filter by category
+       * @param {string[]} [options.tags] - Filter by tags
+       * @param {string} [options.author] - Filter by author
+       * @param {number} [options.limit] - Max results to return
+       * @param {number} [options.offset] - Number of results to skip
+       * @param {boolean} [options.useVector] - Use vector search
+       * @returns {Promise<{results: Array, total: number}>}
+       */
+      async search(query, options = {}) {
+        const params = new URLSearchParams();
+        if (query) params.set("q", query);
+        if (options.category) params.set("category", options.category);
+        if (options.author) params.set("author", options.author);
+        if (options.tags) {
+          options.tags.forEach((tag) => params.append("tags", tag));
+        }
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.offset !== void 0) params.set("offset", String(options.offset));
+        if (options.useVector !== void 0) params.set("useVector", String(options.useVector));
+        return this._get(`/discover/search?${params}`);
+      }
+      /**
+       * Get trending prompts by time window
+       * @param {object} [options] - Trending options
+       * @param {'1h'|'24h'|'7d'|'30d'|'all'} [options.window] - Time window
+       * @param {string} [options.category] - Filter by category
+       * @param {number} [options.limit] - Max results to return
+       * @param {number} [options.offset] - Number of results to skip
+       * @returns {Promise<{results: Array}>}
+       */
+      async trending(options = {}) {
+        const params = new URLSearchParams();
+        if (options.window) params.set("window", options.window);
+        if (options.category) params.set("category", options.category);
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.offset !== void 0) params.set("offset", String(options.offset));
+        return this._get(`/discover/trending?${params}`);
+      }
+      /**
+       * Get trending prompts (alias for /trends/top endpoint)
+       * @param {object} [options] - Trending options
+       * @param {'1h'|'24h'|'7d'|'30d'|'all'} [options.window] - Time window
+       * @param {number} [options.limit] - Max results to return
+       * @param {number} [options.offset] - Number of results to skip
+       * @returns {Promise<{results: Array}>}
+       */
+      async trendingTop(options = {}) {
+        const params = new URLSearchParams();
+        if (options.window) params.set("window", options.window);
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.offset !== void 0) params.set("offset", String(options.offset));
+        return this._get(`/trends/top?${params}`);
+      }
+      /**
+       * Find prompts matching user preferences
+       *
+       * Note: This endpoint is not yet implemented in the backend.
+       * This is a placeholder for future implementation.
+       * @param {object} preferences - User preferences
+       * @param {string[]} [preferences.recentPrompts] - Recent prompt CIDs
+       * @param {string[]} [preferences.preferredTags] - Preferred tags
+       * @param {string[]} [preferences.preferredCategories] - Preferred categories
+       * @param {string[]} [preferences.excludeAuthors] - Authors to exclude
+       * @param {number} [preferences.limit] - Max results
+       * @param {boolean} [preferences.diversify] - Diversify results
+       * @returns {Promise<{results: Array, total: number}>}
+       */
+      async match(preferences) {
+        return this._post("/discover/match", preferences);
+      }
+      /**
+       * Find prompts similar to a given prompt
+       * @param {string} cid - Prompt CID to find similar prompts for
+       * @param {object} [options] - Similar options
+       * @param {number} [options.limit] - Max results to return
+       * @param {'vector'|'keyword'|'hybrid'} [options.method] - Similarity method
+       * @returns {Promise<{similar: Array}>}
+       */
+      async similar(cid, options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.method) params.set("method", options.method);
+        return this._get(`/discover/similar/${cid}?${params}`);
+      }
+      /**
+       * Get popular tags with optional clustering
+       * @param {object} [options] - Tags options
+       * @param {number} [options.limit] - Max tags to return
+       * @param {string} [options.category] - Filter by category
+       * @param {boolean} [options.clusters] - Enable tag clustering
+       * @returns {Promise<{tags: Array}>}
+       */
+      async tags(options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.category) params.set("category", options.category);
+        if (options.clusters !== void 0) params.set("clusters", String(options.clusters));
+        return this._get(`/discover/tags?${params}`);
+      }
+      /**
+       * Get category statistics
+       *
+       * Note: This endpoint is not yet implemented in the backend.
+       * This is a placeholder for future implementation.
+       * @returns {Promise<{categories: Array}>}
+       */
+      async categories() {
+        return this._get("/discover/categories");
+      }
+      /**
+       * Get prompts by tag
+       * @param {string} tag - Tag to search for
+       * @param {number} [limit] - Max results to return
+       * @returns {Promise<{results: Array}>}
+       */
+      async promptsByTag(tag, limit) {
+        const params = new URLSearchParams();
+        if (limit !== void 0) params.set("limit", String(limit));
+        const encodedTag = encodeURIComponent(tag);
+        return this._get(`/discover/by-tag/${encodedTag}?${params}`);
+      }
+      /**
+       * Get index statistics
+       * @returns {Promise<{totalPrompts: number, totalTags: number, avgTrendScore: number}>}
+       */
+      async stats() {
+        return this._get("/discover/stats");
+      }
+      /**
+       * Get trend signals for a specific CID
+       * @param {string} cid - Prompt CID
+       * @returns {Promise<{usageCount: number, forkCount: number, purchaseCount: number, uniqueBuyers: number, governanceVotes: number, lastActivityAt: number}>}
+       */
+      async trendSignals(cid) {
+        return this._get(`/trends/signals/${cid}`);
+      }
+      /**
+       * Get trend history for a specific CID
+       * @param {string} cid - Prompt CID
+       * @param {object} [options] - History options
+       * @param {number} [options.limit] - Max history entries
+       * @param {number} [options.since] - Timestamp to start from
+       * @returns {Promise<{history: Array}>}
+       */
+      async trendHistory(cid, options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.since !== void 0) params.set("since", String(options.since));
+        return this._get(`/trends/history/${cid}?${params}`);
+      }
+      /**
+       * Get trend statistics
+       * @returns {Promise<{totalTracked: number, avgScore: number, maxScore: number, recentlyActive: number}>}
+       */
+      async trendStats() {
+        return this._get("/trends/stats");
+      }
+      /**
+       * Record a usage event for a prompt (requires authentication)
+       * @param {string} cid - Prompt CID
+       * @returns {Promise<{ok: boolean}>}
+       */
+      async recordUsage(cid) {
+        return this._post("/trends/usage", { cid });
+      }
+      // Private fetch helpers
+      /**
+       * Perform a GET request
+       * @private
+       * @param {string} path - API path
+       * @returns {Promise<any>}
+       */
+      async _get(path2) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+          const response = await fetch(`${this.baseUrl}${path2}`, {
+            method: "GET",
+            headers: {
+              "Accept": "application/json",
+              ...this.headers
+            },
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!response.ok) {
+            const errorBody = await response.text().catch(() => "Unknown error");
+            throw new Error(`HTTP ${response.status}: ${errorBody}`);
+          }
+          return await response.json();
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error.name === "AbortError") {
+            throw new Error(`Request timeout after ${this.timeout}ms`);
+          }
+          throw error;
+        }
+      }
+      /**
+       * Perform a POST request
+       * @private
+       * @param {string} path - API path
+       * @param {any} body - Request body
+       * @returns {Promise<any>}
+       */
+      async _post(path2, body) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+          const response = await fetch(`${this.baseUrl}${path2}`, {
+            method: "POST",
+            headers: {
+              "Accept": "application/json",
+              "Content-Type": "application/json",
+              ...this.headers
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!response.ok) {
+            const errorBody = await response.text().catch(() => "Unknown error");
+            throw new Error(`HTTP ${response.status}: ${errorBody}`);
+          }
+          return await response.json();
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error.name === "AbortError") {
+            throw new Error(`Request timeout after ${this.timeout}ms`);
+          }
+          throw error;
+        }
+      }
+    };
+    module2.exports = { DiscoveryClient };
+  }
+});
+
+// src/clients/git-storage-client.js
+var require_git_storage_client = __commonJS({
+  "src/clients/git-storage-client.js"(exports2, module2) {
+    var GitStorageClient = class {
+      /**
+       * @param {string} baseUrl - Base URL of the API (e.g., 'https://api.sageprotocol.io')
+       * @param {Object} [options] - Client options
+       * @param {number} [options.timeout=30000] - Request timeout in milliseconds
+       * @param {Record<string, string>} [options.headers] - Custom headers
+       * @param {AuthProvider} [options.signer] - Ethers signer for authenticated requests
+       * @param {() => Promise<{address: string, signature: string, nonce: string}>} [options.getAuth] - Custom auth provider
+       * @param {string} [options.token] - Bearer token for authentication
+       */
+      constructor(baseUrl, options = {}) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.timeout = options.timeout || 3e4;
+        this.headers = options.headers || {};
+        this.signer = options.signer || null;
+        this.getAuth = options.getAuth || null;
+        this.token = options.token || null;
+        this._authCache = null;
+        this._authCacheExpiry = 0;
+      }
+      // =========================================================================
+      // Library Management
+      // =========================================================================
+      /**
+       * Create a new library
+       * @param {string} subdao - SubDAO address
+       * @param {string} name - Library name
+       * @param {Object} [options] - Creation options
+       * @param {string} [options.description] - Library description
+       * @param {'public'|'private'} [options.visibility='public'] - Library visibility
+       * @returns {Promise<LibraryMetadata>}
+       */
+      async createLibrary(subdao, name, options = {}) {
+        return this._post("/git/libraries", {
+          subdao,
+          name,
+          description: options.description,
+          visibility: options.visibility || "public"
+        }, { auth: true });
+      }
+      /**
+       * Get library metadata
+       * @param {string} subdao - SubDAO address
+       * @returns {Promise<LibraryMetadata>}
+       */
+      async getLibrary(subdao) {
+        return this._get(`/git/libraries/${encodeURIComponent(subdao)}`);
+      }
+      /**
+       * List all libraries
+       * @param {Object} [options] - List options
+       * @param {number} [options.limit=50] - Max results to return
+       * @param {string} [options.cursor] - Pagination cursor
+       * @returns {Promise<{libraries: LibraryMetadata[], cursor?: string}>}
+       */
+      async listLibraries(options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.cursor) params.set("cursor", options.cursor);
+        const queryString = params.toString();
+        return this._get(`/git/libraries${queryString ? "?" + queryString : ""}`);
+      }
+      /**
+       * Delete a library (admin only)
+       * @param {string} subdao - SubDAO address
+       * @returns {Promise<{ok: boolean}>}
+       */
+      async deleteLibrary(subdao) {
+        return this._delete(`/git/libraries/${encodeURIComponent(subdao)}`, { auth: true });
+      }
+      // =========================================================================
+      // Git Object Operations
+      // =========================================================================
+      /**
+       * Store git objects (batch)
+       * @param {string} subdao - SubDAO address
+       * @param {GitObject[]} objects - Objects to store
+       * @returns {Promise<{stored: number}>}
+       */
+      async putObjects(subdao, objects) {
+        return this._post(`/git/${encodeURIComponent(subdao)}/objects`, { objects }, { auth: true });
+      }
+      /**
+       * Get a single git object
+       * @param {string} subdao - SubDAO address
+       * @param {string} oid - Object ID
+       * @returns {Promise<GitObject>}
+       */
+      async getObject(subdao, oid) {
+        return this._get(`/git/${encodeURIComponent(subdao)}/objects/${oid}`);
+      }
+      /**
+       * Get multiple git objects
+       * @param {string} subdao - SubDAO address
+       * @param {string[]} oids - Object IDs
+       * @returns {Promise<{objects: GitObject[]}>}
+       */
+      async getObjects(subdao, oids) {
+        return this._get(`/git/${encodeURIComponent(subdao)}/objects?oids=${oids.join(",")}`);
+      }
+      // =========================================================================
+      // Reference Operations
+      // =========================================================================
+      /**
+       * List all refs
+       * @param {string} subdao - SubDAO address
+       * @returns {Promise<{refs: GitRef[]}>}
+       */
+      async listRefs(subdao) {
+        return this._get(`/git/${encodeURIComponent(subdao)}/refs`);
+      }
+      /**
+       * Get a specific ref
+       * @param {string} subdao - SubDAO address
+       * @param {string} refName - Reference name (e.g., 'refs/heads/main')
+       * @returns {Promise<GitRef>}
+       */
+      async getRef(subdao, refName) {
+        return this._get(`/git/${encodeURIComponent(subdao)}/refs/${encodeURIComponent(refName)}`);
+      }
+      /**
+       * Update a ref
+       * @param {string} subdao - SubDAO address
+       * @param {string} refName - Reference name
+       * @param {string} oid - New object ID
+       * @param {Object} [options] - Update options
+       * @param {string} [options.oldOid] - Expected current OID (for optimistic concurrency)
+       * @returns {Promise<{ok: boolean}>}
+       */
+      async updateRef(subdao, refName, oid, options = {}) {
+        return this._post(
+          `/git/${encodeURIComponent(subdao)}/refs/${encodeURIComponent(refName)}`,
+          { oid, oldOid: options.oldOid },
+          { auth: true }
+        );
+      }
+      // =========================================================================
+      // Sync Operations
+      // =========================================================================
+      /**
+       * Push changes to library
+       * @param {string} subdao - SubDAO address
+       * @param {Object} payload - Push payload
+       * @param {GitObject[]} payload.objects - Objects to push
+       * @param {Record<string, string>} payload.refs - Ref updates (name -> oid)
+       * @param {string} payload.message - Commit message
+       * @returns {Promise<PushResult>}
+       */
+      async push(subdao, payload) {
+        return this._post(`/git/${encodeURIComponent(subdao)}/push`, payload, { auth: true });
+      }
+      /**
+       * Clone a library (get all objects and refs)
+       * @param {string} subdao - SubDAO address
+       * @returns {Promise<{objects: GitObject[], refs: Record<string, string>, metadata: LibraryMetadata}>}
+       */
+      async clone(subdao) {
+        return this._get(`/git/${encodeURIComponent(subdao)}/clone`);
+      }
+      /**
+       * Fetch changes since a commit
+       * @param {string} subdao - SubDAO address
+       * @param {string} [since] - Commit OID to fetch since
+       * @returns {Promise<{objects: GitObject[], refs: Record<string, string>}>}
+       */
+      async fetch(subdao, since) {
+        const params = since ? `?since=${since}` : "";
+        return this._get(`/git/${encodeURIComponent(subdao)}/fetch${params}`);
+      }
+      // =========================================================================
+      // File Access
+      // =========================================================================
+      /**
+       * Get commit history
+       * @param {string} subdao - SubDAO address
+       * @param {Object} [options] - History options
+       * @param {string} [options.ref='refs/heads/main'] - Reference to get history from
+       * @param {number} [options.limit=50] - Max commits to return
+       * @returns {Promise<{commits: GitCommit[]}>}
+       */
+      async getHistory(subdao, options = {}) {
+        const params = new URLSearchParams();
+        if (options.ref) params.set("ref", options.ref);
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        return this._get(`/git/${encodeURIComponent(subdao)}/log?${params}`);
+      }
+      /**
+       * Get directory listing
+       * @param {string} subdao - SubDAO address
+       * @param {string} ref - Reference (e.g., 'main')
+       * @param {string} path - Directory path
+       * @returns {Promise<{entries: Array}>}
+       */
+      async getTree(subdao, ref, path2) {
+        return this._get(
+          `/git/${encodeURIComponent(subdao)}/tree/${encodeURIComponent(ref)}/${encodeURIComponent(path2)}`
+        );
+      }
+      /**
+       * Get file contents
+       * @param {string} subdao - SubDAO address
+       * @param {string} ref - Reference (e.g., 'main')
+       * @param {string} path - File path
+       * @returns {Promise<{content: string}>}
+       */
+      async getBlob(subdao, ref, path2) {
+        return this._get(
+          `/git/${encodeURIComponent(subdao)}/blob/${encodeURIComponent(ref)}/${encodeURIComponent(path2)}`
+        );
+      }
+      /**
+       * Get file contents as string (convenience method)
+       * @param {string} subdao - SubDAO address
+       * @param {string} ref - Reference (e.g., 'main')
+       * @param {string} path - File path
+       * @returns {Promise<string>}
+       */
+      async getFile(subdao, ref, path2) {
+        const result = await this.getBlob(subdao, ref, path2);
+        return result.content;
+      }
+      // =========================================================================
+      // Fork Operations
+      // =========================================================================
+      /**
+       * Fork a library to a new SubDAO
+       * @param {string} sourceSubdao - Source SubDAO address to fork from
+       * @param {string} targetSubdao - Target SubDAO address for the fork
+       * @param {Object} [options] - Fork options
+       * @param {string} [options.targetName] - Name for the forked library
+       * @param {string} [options.targetDescription] - Description for the forked library
+       * @returns {Promise<{ok: boolean, forkedLibrary: string, sourceLibrary: string, commitsCopied: number}>}
+       */
+      async fork(sourceSubdao, targetSubdao, options = {}) {
+        return this._post(`/git/libraries/${encodeURIComponent(sourceSubdao)}/fork`, {
+          targetSubdao,
+          targetName: options.targetName,
+          targetDescription: options.targetDescription
+        }, { auth: true });
+      }
+      /**
+       * List forks of a library
+       * @param {string} subdao - SubDAO address
+       * @returns {Promise<{forks: Array, count: number}>}
+       */
+      async getForks(subdao) {
+        return this._get(`/git/libraries/${encodeURIComponent(subdao)}/forks`);
+      }
+      /**
+       * Get upstream fork info (for forked libraries)
+       * @param {string} subdao - SubDAO address
+       * @returns {Promise<{upstreamSubdao: string, upstreamCommit: string, forkedAt: number}>}
+       */
+      async getUpstream(subdao) {
+        return this._get(`/git/${encodeURIComponent(subdao)}/upstream`);
+      }
+      /**
+       * Check if a library is a fork
+       * @param {string} subdao - SubDAO address
+       * @returns {Promise<boolean>}
+       */
+      async isFork(subdao) {
+        try {
+          await this.getUpstream(subdao);
+          return true;
+        } catch (e) {
+          if (e.message && e.message.includes("404")) {
+            return false;
+          }
+          throw e;
+        }
+      }
+      // =========================================================================
+      // Collaborator Operations
+      // =========================================================================
+      /**
+       * List collaborators
+       * @param {string} subdao - SubDAO address
+       * @returns {Promise<{collaborators: Collaborator[]}>}
+       */
+      async listCollaborators(subdao) {
+        return this._get(`/git/${encodeURIComponent(subdao)}/collaborators`);
+      }
+      /**
+       * Add a collaborator
+       * @param {string} subdao - SubDAO address
+       * @param {string} address - Collaborator wallet address
+       * @param {'read'|'write'|'admin'} permission - Permission level
+       * @returns {Promise<{ok: boolean}>}
+       */
+      async addCollaborator(subdao, address, permission) {
+        return this._post(`/git/${encodeURIComponent(subdao)}/collaborators`, {
+          address,
+          permission
+        }, { auth: true });
+      }
+      /**
+       * Remove a collaborator
+       * @param {string} subdao - SubDAO address
+       * @param {string} address - Collaborator wallet address
+       * @returns {Promise<{ok: boolean}>}
+       */
+      async removeCollaborator(subdao, address) {
+        return this._delete(
+          `/git/${encodeURIComponent(subdao)}/collaborators/${encodeURIComponent(address)}`,
+          { auth: true }
+        );
+      }
+      /**
+       * Check permissions for an address
+       * @param {string} subdao - SubDAO address
+       * @param {string} address - Wallet address to check
+       * @returns {Promise<{canRead: boolean, canWrite: boolean, isAdmin: boolean, permission?: string}>}
+       */
+      async getPermissions(subdao, address) {
+        return this._get(
+          `/git/${encodeURIComponent(subdao)}/collaborators/${encodeURIComponent(address)}/permissions`
+        );
+      }
+      // =========================================================================
+      // High-Level Convenience Methods
+      // =========================================================================
+      /**
+       * Push a manifest file (convenience method)
+       * @param {string} subdao - SubDAO address
+       * @param {Object} manifest - Manifest object to push
+       * @param {string} message - Commit message
+       * @returns {Promise<PushResult>}
+       */
+      async pushManifest(subdao, manifest, message) {
+        const content = JSON.stringify(manifest, null, 2);
+        const oid = await this._computeOid(content);
+        const objects = [{
+          oid,
+          type: "blob",
+          size: content.length,
+          data: this._toBase64(content)
+        }];
+        const treeContent = JSON.stringify({ "manifest.json": oid });
+        const treeOid = await this._computeOid(treeContent);
+        objects.push({
+          oid: treeOid,
+          type: "tree",
+          size: treeContent.length,
+          data: this._toBase64(treeContent)
+        });
+        let parentOid = null;
+        try {
+          const currentRef = await this.getRef(subdao, "refs/heads/main");
+          parentOid = currentRef.oid;
+        } catch (e) {
+        }
+        const author = await this._getAuthAddress();
+        const commitContent = JSON.stringify({
+          tree: treeOid,
+          parent: parentOid,
+          message,
+          author: { address: author },
+          timestamp: Date.now()
+        });
+        const commitOid = await this._computeOid(commitContent);
+        objects.push({
+          oid: commitOid,
+          type: "commit",
+          size: commitContent.length,
+          data: this._toBase64(commitContent)
+        });
+        return this.push(subdao, {
+          objects,
+          refs: { "refs/heads/main": commitOid },
+          message
+        });
+      }
+      /**
+       * Get manifest from library (convenience method)
+       * @param {string} subdao - SubDAO address
+       * @param {string} [ref='main'] - Reference to get manifest from
+       * @returns {Promise<Object>}
+       */
+      async getManifest(subdao, ref = "main") {
+        const content = await this.getFile(subdao, ref, "manifest.json");
+        return JSON.parse(content);
+      }
+      // =========================================================================
+      // Private HTTP Methods
+      // =========================================================================
+      /**
+       * Get authentication headers
+       * @private
+       * @returns {Promise<Record<string, string>>}
+       */
+      async _getAuthHeaders() {
+        if (this._authCache && Date.now() < this._authCacheExpiry) {
+          return this._authCache;
+        }
+        if (this.token) {
+          const headers = { Authorization: `Bearer ${this.token}` };
+          this._authCache = headers;
+          this._authCacheExpiry = Date.now() + 36e5;
+          return headers;
+        }
+        if (typeof this.getAuth === "function") {
+          const auth = await this.getAuth();
+          const headers = {
+            "X-Wallet-Address": auth.address,
+            "X-Wallet-Signature": auth.signature,
+            "X-Wallet-Nonce": auth.nonce
+          };
+          this._authCache = headers;
+          this._authCacheExpiry = Date.now() + 3e5;
+          return headers;
+        }
+        if (this.signer) {
+          const signer = typeof this.signer === "function" ? await this.signer() : this.signer;
+          if (!signer) throw new Error("signer_unavailable");
+          const address = await signer.getAddress();
+          const challengeResponse = await this._post("/ipfs/auth/challenge", { address }, { auth: false });
+          const { message, nonce } = challengeResponse;
+          if (!message || !nonce) throw new Error("challenge_response_invalid");
+          const signature = await signer.signMessage(message);
+          const headers = {
+            "X-Wallet-Address": address,
+            "X-Wallet-Signature": signature,
+            "X-Wallet-Nonce": nonce
+          };
+          this._authCache = headers;
+          this._authCacheExpiry = Date.now() + 3e5;
+          return headers;
+        }
+        return {};
+      }
+      /**
+       * Get authenticated address
+       * @private
+       * @returns {Promise<string>}
+       */
+      async _getAuthAddress() {
+        if (this.signer) {
+          const signer = typeof this.signer === "function" ? await this.signer() : this.signer;
+          return signer.getAddress();
+        }
+        if (typeof this.getAuth === "function") {
+          const auth = await this.getAuth();
+          return auth.address;
+        }
+        return "0x0000000000000000000000000000000000000000";
+      }
+      /**
+       * Perform a GET request
+       * @private
+       * @param {string} path - API path
+       * @param {Object} [options] - Request options
+       * @param {boolean} [options.auth=false] - Whether to include auth headers
+       * @returns {Promise<any>}
+       */
+      async _get(path2, options = {}) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+          const authHeaders = options.auth ? await this._getAuthHeaders() : {};
+          const response = await fetch(`${this.baseUrl}${path2}`, {
+            method: "GET",
+            headers: {
+              Accept: "application/json",
+              ...this.headers,
+              ...authHeaders
+            },
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!response.ok) {
+            const errorBody = await response.text().catch(() => "Unknown error");
+            throw new Error(`HTTP ${response.status}: ${errorBody}`);
+          }
+          return await response.json();
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error.name === "AbortError") {
+            throw new Error(`Request timeout after ${this.timeout}ms`);
+          }
+          throw error;
+        }
+      }
+      /**
+       * Perform a POST request
+       * @private
+       * @param {string} path - API path
+       * @param {any} body - Request body
+       * @param {Object} [options] - Request options
+       * @param {boolean} [options.auth=false] - Whether to include auth headers
+       * @returns {Promise<any>}
+       */
+      async _post(path2, body, options = {}) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+          const authHeaders = options.auth ? await this._getAuthHeaders() : {};
+          const response = await fetch(`${this.baseUrl}${path2}`, {
+            method: "POST",
+            headers: {
+              Accept: "application/json",
+              "Content-Type": "application/json",
+              ...this.headers,
+              ...authHeaders
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!response.ok) {
+            const errorBody = await response.text().catch(() => "Unknown error");
+            throw new Error(`HTTP ${response.status}: ${errorBody}`);
+          }
+          return await response.json();
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error.name === "AbortError") {
+            throw new Error(`Request timeout after ${this.timeout}ms`);
+          }
+          throw error;
+        }
+      }
+      /**
+       * Perform a DELETE request
+       * @private
+       * @param {string} path - API path
+       * @param {Object} [options] - Request options
+       * @param {boolean} [options.auth=false] - Whether to include auth headers
+       * @returns {Promise<any>}
+       */
+      async _delete(path2, options = {}) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+          const authHeaders = options.auth ? await this._getAuthHeaders() : {};
+          const response = await fetch(`${this.baseUrl}${path2}`, {
+            method: "DELETE",
+            headers: {
+              Accept: "application/json",
+              ...this.headers,
+              ...authHeaders
+            },
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!response.ok) {
+            const errorBody = await response.text().catch(() => "Unknown error");
+            throw new Error(`HTTP ${response.status}: ${errorBody}`);
+          }
+          return await response.json();
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error.name === "AbortError") {
+            throw new Error(`Request timeout after ${this.timeout}ms`);
+          }
+          throw error;
+        }
+      }
+      // =========================================================================
+      // Private Utility Methods
+      // =========================================================================
+      /**
+       * Compute a simple hash for object IDs
+       * @private
+       * @param {string} content - Content to hash
+       * @returns {Promise<string>}
+       */
+      async _computeOid(content) {
+        if (typeof crypto !== "undefined" && crypto.subtle) {
+          const encoder = new TextEncoder();
+          const data = encoder.encode(content);
+          const hashBuffer = await crypto.subtle.digest("SHA-1", data);
+          const hashArray = Array.from(new Uint8Array(hashBuffer));
+          return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+        }
+        let hash = 0;
+        for (let i = 0; i < content.length; i++) {
+          const char = content.charCodeAt(i);
+          hash = (hash << 5) - hash + char;
+          hash = hash & hash;
+        }
+        return Math.abs(hash).toString(16).padStart(40, "0");
+      }
+      /**
+       * Convert string to base64
+       * @private
+       * @param {string} str - String to encode
+       * @returns {string}
+       */
+      _toBase64(str) {
+        if (typeof btoa !== "undefined") {
+          return btoa(str);
+        }
+        return Buffer.from(str).toString("base64");
+      }
+      /**
+       * Clear auth cache (useful after logout)
+       */
+      clearAuthCache() {
+        this._authCache = null;
+        this._authCacheExpiry = 0;
+      }
+    };
+    module2.exports = { GitStorageClient };
+  }
+});
+
+// src/clients/index.js
+var require_clients = __commonJS({
+  "src/clients/index.js"(exports2, module2) {
+    var { DiscoveryClient } = require_discovery_client();
+    var { GitStorageClient } = require_git_storage_client();
+    module2.exports = {
+      DiscoveryClient,
+      GitStorageClient
+    };
+  }
+});
+
 // src/hooks/useSubDAOs.js
 var require_useSubDAOs = __commonJS({
   "src/hooks/useSubDAOs.js"(exports2, module2) {
@@ -10120,6 +12893,7 @@ var require_src = __commonJS({
     var timelock = require_timelock();
     var factory = require_factory();
     var library = require_library();
+    var lineage = require_lineage();
     var prompt = require_prompt();
     var { SageEchoExecutor } = require_execute();
     var ipfs = require_ipfs();
@@ -10133,6 +12907,9 @@ var require_src = __commonJS({
     var treasury = require_treasury();
     var boost = require_boost();
     var bounty = require_bounty();
+    var contributions = require_contributions();
+    var votingMultiplier = require_votingMultiplier();
+    var auction = require_auction();
     var wallet = require_wallet();
     wallet.session = require_session();
     var walletCastManager = require_cast_manager();
@@ -10153,6 +12930,7 @@ var require_src = __commonJS({
     var serviceErrors = require_errors2();
     var { SimpleCache } = require_cache();
     var { retryWithBackoff } = require_retry();
+    var { DiscoveryClient, GitStorageClient } = require_clients();
     var hooks = null;
     try {
       hooks = require_hooks();
@@ -10168,6 +12946,7 @@ var require_src = __commonJS({
       timelock,
       factory,
       library,
+      lineage,
       prompt,
       ipfs,
       ipns,
@@ -10180,6 +12959,9 @@ var require_src = __commonJS({
       subgraph,
       utils: { ...utils, privateTx, safe, time },
       bounty,
+      contributions,
+      votingMultiplier,
+      auction,
       wallet: Object.assign(wallet, {
         cast: walletCastManager,
         cdp: walletCdpManager
@@ -10200,6 +12982,13 @@ var require_src = __commonJS({
         SimpleCache,
         retryWithBackoff
       },
+      // Client exports
+      clients: {
+        DiscoveryClient,
+        GitStorageClient
+      },
+      DiscoveryClient,
+      GitStorageClient,
       // React hooks (optional - requires react + swr peer dependencies)
       hooks,
       // Legacy exports (deprecated): maintain compatibility while consumers migrate