@ixo/editor 6.3.0 → 6.5.0

package/dist/{chunk-GUKGNTGT.js → chunk-EULL3QTC.js}

@@ -917,6 +917,8 @@ registerAction({
   requiredCapability: "flow/block/execute",
   outputSchema: [
     { path: "proposalId", displayName: "Proposal ID", type: "string", description: "The on-chain proposal identifier" },
+    { path: "proposalTitle", displayName: "Proposal Title", type: "string", description: "The proposal name voters see on-chain" },
+    { path: "proposalDescription", displayName: "Proposal Description", type: "string", description: "The long-form description voters see on-chain" },
     { path: "status", displayName: "Proposal Status", type: "string", description: "Current proposal status (open, passed, rejected, executed, etc.)" },
     { path: "proposalContractAddress", displayName: "Proposal Contract Address", type: "string", description: "The proposal module contract address" },
     { path: "coreAddress", displayName: "Core Address", type: "string", description: "The DAO core contract address" },
@@ -976,6 +978,8 @@ registerAction({
     return {
       output: {
         proposalId: String(proposalId),
+        proposalTitle: title,
+        proposalDescription: description,
         status: "open",
         proposalContractAddress: proposalContractAddress || "",
         coreAddress,
@@ -1003,6 +1007,8 @@ registerAction({
   requiredCapability: "flow/block/execute",
   outputSchema: [
     { path: "proposalId", displayName: "Proposal ID", type: "string", description: "The on-chain proposal identifier" },
+    { path: "proposalTitle", displayName: "Proposal Title", type: "string", description: "The proposal name voters see on-chain" },
+    { path: "proposalDescription", displayName: "Proposal Description", type: "string", description: "The long-form description voters see on-chain" },
     { path: "status", displayName: "Proposal Status", type: "string", description: "Current proposal status (open, passed, rejected, executed, etc.)" },
     { path: "proposalContractAddress", displayName: "Proposal Contract Address", type: "string", description: "The proposal module contract address" },
     { path: "coreAddress", displayName: "Core Address", type: "string", description: "The DAO core contract address" },
@@ -1040,7 +1046,7 @@ registerAction({
     };
     const updateVotingConfigAction = { type: "UpdateVotingConfig", data };
     const title = String(inputs.title || "").trim() || "Update governance settings";
-    const description = String(inputs.description || "").trim() || "Updates the group's voting rules once the proposal passes.";
+    const description = String(inputs.description || "").trim() || "Updates the POD's voting rules once the proposal passes.";
     const { preProposalContractAddress } = await handlers.getPreProposalContractAddress({ coreAddress });
     const { groupContractAddress } = await handlers.getGroupContractAddress({ coreAddress });
     const { proposalContractAddress } = await handlers.getProposalContractAddress({ coreAddress });
@@ -1058,6 +1064,8 @@ registerAction({
     return {
       output: {
         proposalId: String(proposalId),
+        proposalTitle: title,
+        proposalDescription: description,
         status: "open",
         proposalContractAddress: proposalContractAddress || "",
         coreAddress,
@@ -1067,6 +1075,121 @@ registerAction({
   }
 });
 
+// src/core/lib/actionRegistry/actions/governance/_shared.ts
+var STANDARD_OUTPUT_SCHEMA = [
+  { path: "proposalId", displayName: "Proposal ID", type: "string", description: "The on-chain proposal identifier" },
+  { path: "proposalTitle", displayName: "Proposal Title", type: "string", description: "The proposal name voters see on-chain" },
+  { path: "proposalDescription", displayName: "Proposal Description", type: "string", description: "The long-form description voters see on-chain" },
+  { path: "status", displayName: "Proposal Status", type: "string", description: "Current proposal status (open, passed, rejected, executed, etc.)" },
+  { path: "proposalContractAddress", displayName: "Proposal Contract Address", type: "string", description: "The proposal module contract address" },
+  { path: "coreAddress", displayName: "Core Address", type: "string", description: "The DAO core contract address" },
+  { path: "createdAt", displayName: "Created At", type: "string", description: "ISO timestamp of proposal creation" }
+];
+function registerGovernanceProposalAction(spec) {
+  registerAction({
+    type: spec.type,
+    can: spec.can,
+    sideEffect: true,
+    proof: { fields: ["proposalId"] },
+    defaultRequiresConfirmation: true,
+    requiredCapability: "flow/block/execute",
+    outputSchema: [...STANDARD_OUTPUT_SCHEMA, ...spec.extraOutputSchema || []],
+    run: async (inputs, ctx) => {
+      const handlers = ctx.handlers;
+      if (!handlers) {
+        throw new Error("Handlers not available");
+      }
+      if (!handlers.getPreProposalContractAddress || !handlers.getGroupContractAddress || !handlers.getProposalContractAddress || !handlers.createProposal) {
+        throw new Error("Governance proposal handlers not available");
+      }
+      const coreAddress = String(inputs.coreAddress || "").trim();
+      if (!coreAddress) throw new Error("coreAddress is required");
+      const actions2 = spec.buildActions(inputs);
+      if (!actions2.length) throw new Error("The proposal must contain at least one action");
+      const title = String(inputs.title || "").trim() || spec.defaultTitle(inputs);
+      const description = String(inputs.description || "").trim() || (spec.defaultDescription ? spec.defaultDescription(inputs) : title);
+      const { preProposalContractAddress } = await handlers.getPreProposalContractAddress({ coreAddress });
+      const { groupContractAddress } = await handlers.getGroupContractAddress({ coreAddress });
+      const { proposalContractAddress } = await handlers.getProposalContractAddress({ coreAddress });
+      const proposalId = await handlers.createProposal({
+        preProposalContractAddress,
+        title,
+        description,
+        actions: actions2,
+        coreAddress,
+        groupContractAddress
+      });
+      if (proposalId === void 0 || proposalId === null || String(proposalId).trim() === "") {
+        throw new Error("Proposal creation returned no proposal id. Check the handler logs.");
+      }
+      return {
+        output: {
+          proposalId: String(proposalId),
+          proposalTitle: title,
+          proposalDescription: description,
+          status: "open",
+          proposalContractAddress: proposalContractAddress || "",
+          coreAddress,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          ...spec.buildExtraOutput ? spec.buildExtraOutput(inputs) : {}
+        }
+      };
+    }
+  });
+}
+
+// src/core/lib/actionRegistry/actions/governance/submissionConfigProposal.ts
+var REFUND_POLICIES = ["always", "only_passed", "never"];
+registerGovernanceProposalAction({
+  type: "qi/governance.submission-config-proposal",
+  can: "governance/submission-config-proposal",
+  buildActions: (inputs) => {
+    const anyoneCanPropose = Boolean(inputs.anyoneCanPropose);
+    const depositRequired = Boolean(inputs.depositRequired);
+    let amount = "0";
+    let refundPolicy = "always";
+    if (depositRequired) {
+      amount = String(inputs.depositAmount || "").trim();
+      if (!/^\d+$/.test(amount) || BigInt(amount) <= 0n) {
+        throw new Error("depositAmount must be a positive whole number in uixo base units");
+      }
+      const policy = String(inputs.depositRefundPolicy || "").trim();
+      if (!REFUND_POLICIES.includes(policy)) {
+        throw new Error("depositRefundPolicy must be one of 'always', 'only_passed' or 'never'");
+      }
+      refundPolicy = policy;
+    }
+    return [
+      {
+        type: "UpdatePreProposeConfig",
+        data: {
+          depositRequired,
+          // Deposit token fixed to the chain's native IXO (uixo) for now.
+          depositInfo: { amount, type: "native", denomOrAddress: "uixo", refundPolicy },
+          anyoneCanPropose
+        }
+      }
+    ];
+  },
+  defaultTitle: () => "Update proposal submission rules",
+  defaultDescription: () => "Updates who may submit proposals and the required deposit once the proposal passes.",
+  buildExtraOutput: (inputs) => {
+    const depositRequired = Boolean(inputs.depositRequired);
+    return {
+      anyoneCanPropose: String(Boolean(inputs.anyoneCanPropose)),
+      depositRequired: String(depositRequired),
+      depositAmount: depositRequired ? String(inputs.depositAmount || "") : "0",
+      depositRefundPolicy: depositRequired ? String(inputs.depositRefundPolicy || "") : "always"
+    };
+  },
+  extraOutputSchema: [
+    { path: "anyoneCanPropose", displayName: "Anyone Can Propose", type: "string", description: "Whether non-members may submit proposals after the update" },
+    { path: "depositRequired", displayName: "Deposit Required", type: "string", description: "Whether a deposit is required to submit a proposal" },
+    { path: "depositAmount", displayName: "Deposit Amount", type: "string", description: "Required deposit in uixo base units" },
+    { path: "depositRefundPolicy", displayName: "Deposit Refund Policy", type: "string", description: "What happens to the deposit after voting ends" }
+  ]
+});
+
 // src/core/lib/actionRegistry/actions/governance/transactionSendFunds.ts
 registerAction({
   type: "qi/governance.transaction.send-funds",
@@ -1077,6 +1200,8 @@ registerAction({
   requiredCapability: "flow/block/execute",
   outputSchema: [
     { path: "proposalId", displayName: "Proposal ID", type: "string", description: "The on-chain proposal identifier" },
+    { path: "proposalTitle", displayName: "Proposal Title", type: "string", description: "The proposal name voters see on-chain" },
+    { path: "proposalDescription", displayName: "Proposal Description", type: "string", description: "The long-form description voters see on-chain" },
     { path: "status", displayName: "Proposal Status", type: "string", description: "Current proposal status (open, passed, rejected, executed, etc.)" },
     { path: "proposalContractAddress", displayName: "Proposal Contract Address", type: "string", description: "The proposal module contract address" },
     { path: "coreAddress", displayName: "Core Address", type: "string", description: "The DAO core contract address" },
@@ -1109,7 +1234,7 @@ registerAction({
     const baseAmount = BigInt(Math.round(amount * 10 ** tokenInfo.exponent)).toString();
     const spendAction = { type: "Spend", data: { to: recipient, denom, amount: baseAmount } };
     const title = String(inputs.title || "").trim() || `Send ${amount} ${tokenInfo.symbol} to ${recipient}`;
-    const description = String(inputs.description || "").trim() || "Sends funds from the group treasury once the proposal passes.";
+    const description = String(inputs.description || "").trim() || "Sends funds from the POD treasury once the proposal passes.";
     const { preProposalContractAddress } = await handlers.getPreProposalContractAddress({ coreAddress });
     const { groupContractAddress } = await handlers.getGroupContractAddress({ coreAddress });
     const { proposalContractAddress } = await handlers.getProposalContractAddress({ coreAddress });
@@ -1127,6 +1252,8 @@ registerAction({
     return {
       output: {
         proposalId: String(proposalId),
+        proposalTitle: title,
+        proposalDescription: description,
         status: "open",
         proposalContractAddress: proposalContractAddress || "",
         coreAddress,
@@ -1137,6 +1264,847 @@ registerAction({
   }
 });
 
+// src/core/lib/actionRegistry/actions/governance/transactionSendGroupToken.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.transaction.send-group-token",
+  can: "governance.transaction/send-group-token",
+  buildActions: (inputs) => {
+    const contract = String(inputs.tokenContract || "").trim();
+    if (!contract) throw new Error("tokenContract is required");
+    const toAddress = String(inputs.recipient || "").trim();
+    if (!toAddress) throw new Error("recipient is required");
+    const amount = String(inputs.amount || "").trim();
+    if (!/^\d+$/.test(amount) || BigInt(amount) <= 0n) {
+      throw new Error("amount must be a positive whole number in the token\u2019s base units");
+    }
+    return [{ type: "SendGroupToken", data: { contract, toAddress, amount } }];
+  },
+  defaultTitle: (inputs) => `Send ${inputs.amount} group tokens to ${inputs.recipient}`,
+  defaultDescription: () => "Transfers group tokens from the treasury once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ recipient: String(inputs.recipient || ""), tokenContract: String(inputs.tokenContract || "") }),
+  extraOutputSchema: [
+    { path: "recipient", displayName: "Recipient", type: "string", description: "Destination address of the transfer" },
+    { path: "tokenContract", displayName: "Token Contract", type: "string", description: "The cw20 token contract transferred from" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/transactionMint.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.transaction.mint",
+  can: "governance.transaction/mint",
+  buildActions: (inputs) => {
+    const to = String(inputs.recipient || "").trim();
+    if (!to) throw new Error("recipient is required");
+    const amount = String(inputs.amount ?? "").trim();
+    if (!/^\d+$/.test(amount) || BigInt(amount) <= 0n) {
+      throw new Error("amount must be a positive whole number in the token\u2019s base units");
+    }
+    return [{ type: "Mint", data: { to, amount } }];
+  },
+  defaultTitle: (inputs) => `Mint ${inputs.amount} governance tokens to ${inputs.recipient}`,
+  defaultDescription: () => "Mints new governance tokens to the recipient once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ recipient: String(inputs.recipient || ""), amount: String(inputs.amount || "") }),
+  extraOutputSchema: [
+    { path: "recipient", displayName: "Recipient", type: "string", description: "Destination address the tokens are minted to" },
+    { path: "amount", displayName: "Amount", type: "string", description: "Number of governance tokens minted" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/transactionPerformTokenSwap.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.transaction.perform-token-swap",
+  can: "governance.transaction/perform-token-swap",
+  buildActions: (inputs) => {
+    const tokenSwapContractAddress = String(inputs.tokenSwapContractAddress || "").trim();
+    if (!tokenSwapContractAddress) throw new Error("tokenSwapContractAddress is required");
+    const type = String(inputs.selfPartyType || "").trim();
+    if (type !== "native" && type !== "cw20") throw new Error("selfPartyType must be 'native' or 'cw20'");
+    const denomOrAddress = String(inputs.selfPartyDenomOrAddress || "").trim();
+    if (!denomOrAddress) throw new Error("selfPartyDenomOrAddress is required");
+    const amount = String(inputs.selfPartyAmount || "").trim();
+    if (!/^\d+$/.test(amount) || BigInt(amount) <= 0n) {
+      throw new Error("selfPartyAmount must be a positive whole number in the token\u2019s base units");
+    }
+    return [
+      {
+        type: "PerformTokenSwap",
+        data: { contractChosen: true, tokenSwapContractAddress, selfParty: { type, denomOrAddress, amount } }
+      }
+    ];
+  },
+  defaultTitle: (inputs) => `Fund token swap ${inputs.tokenSwapContractAddress}`,
+  defaultDescription: () => "Sends the group\u2019s side of the token swap to the swap contract once the proposal passes.",
+  buildExtraOutput: (inputs) => ({
+    tokenSwapContractAddress: String(inputs.tokenSwapContractAddress || ""),
+    selfPartyDenomOrAddress: String(inputs.selfPartyDenomOrAddress || ""),
+    selfPartyAmount: String(inputs.selfPartyAmount || "")
+  }),
+  extraOutputSchema: [
+    { path: "tokenSwapContractAddress", displayName: "Swap Contract", type: "string", description: "The cw-token-swap contract funded" },
+    { path: "selfPartyDenomOrAddress", displayName: "Token Denom / Address", type: "string", description: "The native denom or cw20 address the group provides" },
+    { path: "selfPartyAmount", displayName: "Amount", type: "string", description: "Amount provided, in the token\u2019s base units" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/transactionWithdrawTokenSwap.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.transaction.withdraw-token-swap",
+  can: "governance.transaction/withdraw-token-swap",
+  buildActions: (inputs) => {
+    const tokenSwapContractAddress = String(inputs.tokenSwapContractAddress || "").trim();
+    if (!tokenSwapContractAddress) throw new Error("tokenSwapContractAddress is required");
+    return [{ type: "WithdrawTokenSwap", data: { contractChosen: true, tokenSwapContractAddress } }];
+  },
+  defaultTitle: (inputs) => `Withdraw from token swap ${inputs.tokenSwapContractAddress}`,
+  defaultDescription: () => "Returns the group\u2019s funds from the token swap contract once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ tokenSwapContractAddress: String(inputs.tokenSwapContractAddress || "") }),
+  extraOutputSchema: [{ path: "tokenSwapContractAddress", displayName: "Swap Contract", type: "string", description: "The cw-token-swap contract withdrawn from" }]
+});
+
+// src/core/lib/actionRegistry/actions/governance/stakingStake.ts
+var STAKE_TYPES = ["delegate", "undelegate", "redelegate", "withdraw_delegator_reward"];
+var displayIxo = (amount) => {
+  const base = Number(amount);
+  return Number.isFinite(base) ? String(base / 1e6) : String(amount || "");
+};
+registerGovernanceProposalAction({
+  type: "qi/governance.staking.stake",
+  can: "governance.staking/stake",
+  buildActions: (inputs) => {
+    const stakeType = String(inputs.stakeType || "").trim();
+    if (!STAKE_TYPES.includes(stakeType)) {
+      throw new Error("stakeType must be delegate, undelegate, redelegate or withdraw_delegator_reward");
+    }
+    const validator = String(inputs.validator || "").trim();
+    if (!validator) throw new Error("validator is required");
+    const isRedelegate = stakeType === "redelegate";
+    const toValidator = String(inputs.toValidator || "").trim();
+    if (isRedelegate && !toValidator) throw new Error("toValidator is required for redelegations");
+    let amount = "0";
+    if (stakeType !== "withdraw_delegator_reward") {
+      amount = String(inputs.amount || "").trim();
+      if (!/^\d+$/.test(amount) || BigInt(amount) <= 0n) {
+        throw new Error("amount must be a positive whole number of uixo (base units)");
+      }
+    }
+    return [{ type: "Stake", data: { stakeType, validator, toValidator: isRedelegate ? toValidator : "", amount, denom: "uixo" } }];
+  },
+  // buildActions runs first, so the stake type is always a valid option here.
+  defaultTitle: (inputs) => {
+    switch (String(inputs.stakeType)) {
+      case "undelegate":
+        return `Unstake ${displayIxo(inputs.amount)} IXO from ${inputs.validator}`;
+      case "redelegate":
+        return `Restake ${displayIxo(inputs.amount)} IXO from ${inputs.validator} to ${inputs.toValidator}`;
+      case "withdraw_delegator_reward":
+        return `Claim staking rewards from ${inputs.validator}`;
+      default:
+        return `Stake ${displayIxo(inputs.amount)} IXO with ${inputs.validator}`;
+    }
+  },
+  defaultDescription: () => "Executes the staking operation from the POD treasury once the proposal passes.",
+  buildExtraOutput: (inputs) => ({
+    stakeType: String(inputs.stakeType || ""),
+    validator: String(inputs.validator || ""),
+    amount: String(inputs.amount || "")
+  }),
+  extraOutputSchema: [
+    { path: "stakeType", displayName: "Stake Type", type: "string", description: "The staking operation (delegate, undelegate, redelegate, withdraw_delegator_reward)" },
+    { path: "validator", displayName: "Validator", type: "string", description: "The validator the operation targets (source for redelegations)" },
+    { path: "amount", displayName: "Amount", type: "string", description: "The uixo amount staked, in base units" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/stakingStakeToGroup.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.staking.stake-to-group",
+  can: "governance.staking/stake-to-group",
+  buildActions: (inputs) => {
+    const tokenContract = String(inputs.tokenContract || "").trim();
+    if (!tokenContract) throw new Error("tokenContract is required");
+    const stakingContract = String(inputs.stakingContract || "").trim();
+    if (!stakingContract) throw new Error("stakingContract is required");
+    const amount = String(inputs.amount || "").trim();
+    if (!/^\d+$/.test(amount) || BigInt(amount) <= 0n) {
+      throw new Error("amount must be a positive whole number in the token\u2019s base units");
+    }
+    return [{ type: "StakeToGroup", data: { tokenContract, stakingContract, amount } }];
+  },
+  defaultTitle: (inputs) => `Stake ${inputs.amount} tokens to the group`,
+  defaultDescription: () => "Stakes treasury tokens into the group staking contract once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ tokenContract: String(inputs.tokenContract || ""), stakingContract: String(inputs.stakingContract || "") }),
+  extraOutputSchema: [
+    { path: "tokenContract", displayName: "Token Contract", type: "string", description: "The cw20 token contract the tokens are sent from" },
+    { path: "stakingContract", displayName: "Staking Contract", type: "string", description: "The staking contract the tokens are staked into" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/authzGrant.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.authz.grant",
+  can: "governance.authz/grant",
+  buildActions: (inputs) => {
+    const grantee = String(inputs.grantee || "").trim();
+    if (!grantee) throw new Error("grantee is required");
+    const msgTypeUrl = String(inputs.msgTypeUrl || "").trim();
+    if (!msgTypeUrl) throw new Error("msgTypeUrl is required");
+    if (!msgTypeUrl.startsWith("/")) {
+      throw new Error('msgTypeUrl must be a fully-qualified message type URL starting with "/"');
+    }
+    return [{ type: "AuthzGrant", data: { typeUrl: "/cosmos.authz.v1beta1.MsgGrant", value: { grantee, msgTypeUrl } } }];
+  },
+  defaultTitle: (inputs) => `Grant ${inputs.msgTypeUrl} authorization to ${inputs.grantee}`,
+  defaultDescription: () => "Authorizes the grantee to execute the message type on the group\u2019s behalf (1-year expiry) once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ grantee: String(inputs.grantee || ""), msgTypeUrl: String(inputs.msgTypeUrl || "") }),
+  extraOutputSchema: [
+    { path: "grantee", displayName: "Grantee", type: "string", description: "Address that receives the authorization" },
+    { path: "msgTypeUrl", displayName: "Message Type URL", type: "string", description: "The message type the grantee may execute" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/authzRevoke.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.authz.revoke",
+  can: "governance.authz/revoke",
+  buildActions: (inputs) => {
+    const grantee = String(inputs.grantee || "").trim();
+    if (!grantee) throw new Error("grantee is required");
+    const msgTypeUrl = String(inputs.msgTypeUrl || "").trim();
+    if (!msgTypeUrl) throw new Error("msgTypeUrl is required");
+    if (!msgTypeUrl.startsWith("/")) {
+      throw new Error('msgTypeUrl must be a fully-qualified message type URL starting with "/"');
+    }
+    return [{ type: "AuthzRevoke", data: { typeUrl: "/cosmos.authz.v1beta1.MsgRevoke", value: { grantee, msgTypeUrl } } }];
+  },
+  defaultTitle: (inputs) => `Revoke ${inputs.msgTypeUrl} authorization from ${inputs.grantee}`,
+  defaultDescription: () => "Revokes the grantee\u2019s authorization to execute the message type on the group\u2019s behalf once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ grantee: String(inputs.grantee || ""), msgTypeUrl: String(inputs.msgTypeUrl || "") }),
+  extraOutputSchema: [
+    { path: "grantee", displayName: "Grantee", type: "string", description: "Address whose authorization is revoked" },
+    { path: "msgTypeUrl", displayName: "Message Type URL", type: "string", description: "The message type of the revoked grant" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/authzExec.ts
+var AUTHZ_EXEC_ACTION_TYPES = {
+  delegate: "/cosmos.staking.v1beta1.MsgDelegate",
+  undelegate: "/cosmos.staking.v1beta1.MsgUndelegate",
+  redelegate: "/cosmos.staking.v1beta1.MsgBeginRedelegate",
+  claimRewards: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+  custom: "custom"
+};
+var ACTION_LABELS = {
+  [AUTHZ_EXEC_ACTION_TYPES.delegate]: "delegate",
+  [AUTHZ_EXEC_ACTION_TYPES.undelegate]: "undelegate",
+  [AUTHZ_EXEC_ACTION_TYPES.redelegate]: "redelegate",
+  [AUTHZ_EXEC_ACTION_TYPES.claimRewards]: "claim-rewards",
+  [AUTHZ_EXEC_ACTION_TYPES.custom]: "custom"
+};
+registerGovernanceProposalAction({
+  type: "qi/governance.authz.exec",
+  can: "governance.authz/exec",
+  buildActions: (inputs) => {
+    const actionType = String(inputs.authzExecActionType || "").trim();
+    const known = Object.values(AUTHZ_EXEC_ACTION_TYPES);
+    if (!known.includes(actionType)) {
+      throw new Error(`authzExecActionType must be one of: ${known.join(", ")}`);
+    }
+    const delegator = String(inputs.delegatorAddress || "").trim();
+    const validator = String(inputs.validatorAddress || "").trim();
+    const validatorDst = String(inputs.validatorDstAddress || "").trim();
+    const amount = String(inputs.amount || "").trim();
+    const requireStakingFields = () => {
+      if (!delegator) throw new Error("delegatorAddress is required");
+      if (!validator) throw new Error("validatorAddress is required");
+      if (!/^\d+$/.test(amount) || BigInt(amount) <= 0n) {
+        throw new Error("amount must be a positive whole number in uixo base units");
+      }
+    };
+    const data = {
+      authzExecActionType: actionType,
+      delegate: {},
+      undelegate: {},
+      redelegate: {},
+      claimRewards: {},
+      custom: ""
+    };
+    switch (actionType) {
+      case AUTHZ_EXEC_ACTION_TYPES.delegate:
+        requireStakingFields();
+        data.delegate = { delegatorAddress: delegator, validatorAddress: validator, amount: { denom: "uixo", amount } };
+        break;
+      case AUTHZ_EXEC_ACTION_TYPES.undelegate:
+        requireStakingFields();
+        data.undelegate = { delegatorAddress: delegator, validatorAddress: validator, amount: { denom: "uixo", amount } };
+        break;
+      case AUTHZ_EXEC_ACTION_TYPES.redelegate:
+        requireStakingFields();
+        if (!validatorDst) throw new Error("validatorDstAddress is required");
+        data.redelegate = { delegatorAddress: delegator, validatorSrcAddress: validator, validatorDstAddress: validatorDst, amount: { denom: "uixo", amount } };
+        break;
+      case AUTHZ_EXEC_ACTION_TYPES.claimRewards:
+        if (!delegator) throw new Error("delegatorAddress is required");
+        if (!validator) throw new Error("validatorAddress is required");
+        data.claimRewards = { delegatorAddress: delegator, validatorAddress: validator };
+        break;
+      case AUTHZ_EXEC_ACTION_TYPES.custom: {
+        const custom = String(inputs.custom || "").trim();
+        if (!custom) throw new Error("custom is required");
+        let parsed;
+        try {
+          parsed = JSON.parse(custom);
+        } catch {
+          throw new Error("custom must be valid JSON");
+        }
+        if (!Array.isArray(parsed) || parsed.length === 0) {
+          throw new Error("custom must be a non-empty JSON array of encoded msgs");
+        }
+        data.custom = custom;
+        break;
+      }
+    }
+    return [{ type: "AuthzExec", data }];
+  },
+  defaultTitle: (inputs) => `Execute authorized ${ACTION_LABELS[String(inputs.authzExecActionType || "").trim()] || "authz"} action`,
+  defaultDescription: () => "Executes a message the group was previously authorized to run once the proposal passes.",
+  buildExtraOutput: (inputs) => ({
+    authzExecActionType: String(inputs.authzExecActionType || ""),
+    validatorAddress: String(inputs.validatorAddress || "")
+  }),
+  extraOutputSchema: [
+    { path: "authzExecActionType", displayName: "Exec Action Type", type: "string", description: "The executed message type URL (or `custom`)" },
+    { path: "validatorAddress", displayName: "Validator Address", type: "string", description: "The validator targeted by staking ops (empty for custom)" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/chainGovernanceVote.ts
+var VOTE_LABELS = { 1: "Yes", 2: "Abstain", 3: "No", 4: "No with veto" };
+registerGovernanceProposalAction({
+  type: "qi/governance.chain-governance-vote",
+  can: "governance/chain-governance-vote",
+  buildActions: (inputs) => {
+    const proposalId = String(inputs.proposalId || "").trim();
+    if (!/^\d+$/.test(proposalId)) {
+      throw new Error("proposalId must be a chain governance proposal number (digits only)");
+    }
+    const vote = Number(inputs.vote);
+    if (!VOTE_LABELS[vote]) {
+      throw new Error("vote must be 1 (Yes), 2 (Abstain), 3 (No) or 4 (No with veto)");
+    }
+    return [{ type: "GovernanceVote", data: { proposalId, vote } }];
+  },
+  // buildActions runs first, so the vote is always a valid option here.
+  defaultTitle: (inputs) => `Vote ${VOTE_LABELS[Number(inputs.vote)]} on chain governance proposal #${inputs.proposalId}`,
+  defaultDescription: () => "Casts the group's vote on the chain governance proposal once this proposal passes.",
+  buildExtraOutput: (inputs) => ({
+    chainProposalId: String(inputs.proposalId || ""),
+    voteOption: VOTE_LABELS[Number(inputs.vote)] || String(inputs.vote || "")
+  }),
+  extraOutputSchema: [
+    { path: "chainProposalId", displayName: "Chain Proposal ID", type: "string", description: "The chain governance proposal the POD votes on" },
+    { path: "voteOption", displayName: "Vote Option", type: "string", description: "The vote cast (Yes, Abstain, No, No with veto)" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/daoJoin.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.dao.join",
+  can: "governance.dao/join",
+  buildActions: (inputs) => {
+    const id = String(inputs.entityDid || "").trim();
+    if (!id) throw new Error("entityDid is required");
+    const address = String(inputs.memberId || "").trim();
+    if (!address) throw new Error("memberId is required");
+    const coreAddress = String(inputs.coreAddress || "").trim();
+    return [{ type: "Join", data: { id, coreAddress, address } }];
+  },
+  defaultTitle: (inputs) => `Join entity ${inputs.entityDid}`,
+  defaultDescription: (inputs) => `Links ${inputs.memberId} as a member of ${inputs.entityDid} once the proposal passes.`,
+  buildExtraOutput: (inputs) => ({ entityDid: String(inputs.entityDid || ""), memberId: String(inputs.memberId || "") }),
+  extraOutputSchema: [
+    { path: "entityDid", displayName: "Entity DID", type: "string", description: "The entity the group joined" },
+    { path: "memberId", displayName: "Member ID", type: "string", description: "The member DID/id recorded as the linked entity" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/daoUpdateInfo.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.dao.update-info",
+  can: "governance.dao/update-info",
+  buildActions: (inputs) => {
+    const name = String(inputs.name || "").trim();
+    if (!name) throw new Error("name is required");
+    const daoDescription = String(inputs.daoDescription || "").trim();
+    const imageUrl = String(inputs.imageUrl || "").trim();
+    return [
+      {
+        type: "UpdateInfo",
+        data: {
+          name,
+          description: daoDescription,
+          automatically_add_cw20s: inputs.automaticallyAddCw20s === true || inputs.automaticallyAddCw20s === "true",
+          automatically_add_cw721s: inputs.automaticallyAddCw721s === true || inputs.automaticallyAddCw721s === "true",
+          image_url: imageUrl || null
+        }
+      }
+    ];
+  },
+  defaultTitle: (inputs) => `Update DAO info to \u201C${inputs.name}\u201D`,
+  defaultDescription: () => "Replaces the DAO name, description, image and auto-add settings once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ daoName: String(inputs.name || "") }),
+  extraOutputSchema: [{ path: "daoName", displayName: "DAO Name", type: "string", description: "The DAO display name the proposal sets" }]
+});
+
+// src/core/lib/actionRegistry/actions/governance/daoManageSubDaos.ts
+function normalizeAddresses(value) {
+  return (Array.isArray(value) ? value : []).map((entry) => String(typeof entry === "string" ? entry : entry?.addr || entry?.address || "").trim());
+}
+registerGovernanceProposalAction({
+  type: "qi/governance.dao.manage-subdaos",
+  can: "governance.dao/manage-subdaos",
+  buildActions: (inputs) => {
+    const toAdd = normalizeAddresses(inputs.toAdd);
+    const toRemove = normalizeAddresses(inputs.toRemove);
+    if (toAdd.some((addr) => !addr) || toRemove.some((addr) => !addr)) {
+      throw new Error("Every SubDAO entry needs an address");
+    }
+    if (toAdd.length + toRemove.length === 0) {
+      throw new Error("Add or remove at least one SubDAO");
+    }
+    const all = [...toAdd, ...toRemove];
+    if (new Set(all).size !== all.length) throw new Error("Duplicate SubDAO addresses are not allowed");
+    return [
+      {
+        type: "ManageSubDaos",
+        data: {
+          toAdd: toAdd.map((addr) => ({ addr })),
+          toRemove: toRemove.map((address) => ({ address }))
+        }
+      }
+    ];
+  },
+  defaultTitle: (inputs) => {
+    const added = normalizeAddresses(inputs.toAdd).length;
+    const removed = normalizeAddresses(inputs.toRemove).length;
+    return `Add ${added} and remove ${removed} SubDAOs`;
+  },
+  defaultDescription: () => "Updates the set of SubDAOs this DAO recognises once the proposal passes.",
+  buildExtraOutput: (inputs) => ({
+    addedCount: String(normalizeAddresses(inputs.toAdd).length),
+    removedCount: String(normalizeAddresses(inputs.toRemove).length)
+  }),
+  extraOutputSchema: [
+    { path: "addedCount", displayName: "SubDAOs Added", type: "string", description: "Number of SubDAOs the proposal recognises" },
+    { path: "removedCount", displayName: "SubDAOs Removed", type: "string", description: "Number of SubDAOs the proposal removes" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/daoManageStorage.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.dao.manage-storage",
+  can: "governance.dao/manage-storage",
+  buildActions: (inputs) => {
+    const setting = inputs.setting === true || inputs.setting === "true";
+    const key = String(inputs.key || "").trim();
+    if (!key) throw new Error("key is required");
+    const value = String(inputs.value || "").trim();
+    if (setting && !value) throw new Error("value is required when setting a storage item");
+    return [{ type: "ManageStorageItems", data: { setting, key, value: setting ? value : "" } }];
+  },
+  defaultTitle: (inputs) => {
+    const setting = inputs.setting === true || inputs.setting === "true";
+    return setting ? `Set storage item \u201C${inputs.key}\u201D` : `Remove storage item \u201C${inputs.key}\u201D`;
+  },
+  defaultDescription: () => "Updates the DAO's on-chain key/value storage once the proposal passes.",
+  buildExtraOutput: (inputs) => ({
+    storageKey: String(inputs.key || ""),
+    storageAction: inputs.setting === true || inputs.setting === "true" ? "set" : "remove"
+  }),
+  extraOutputSchema: [
+    { path: "storageKey", displayName: "Storage Key", type: "string", description: "The storage key the proposal targets" },
+    { path: "storageAction", displayName: "Storage Action", type: "string", description: "set | remove" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/daoAdminExec.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.dao.admin-exec",
+  can: "governance.dao/admin-exec",
+  buildActions: (inputs) => {
+    const targetCoreAddress = String(inputs.targetCoreAddress || "").trim();
+    if (!targetCoreAddress) throw new Error("targetCoreAddress is required");
+    let msgs = inputs.msgs;
+    if (typeof msgs === "string") {
+      try {
+        msgs = JSON.parse(msgs);
+      } catch {
+        throw new Error("msgs must be valid JSON");
+      }
+    }
+    if (!Array.isArray(msgs) || msgs.length === 0) {
+      throw new Error("msgs must be a non-empty JSON array of messages");
+    }
+    return [{ type: "DaoAdminExec", data: { coreAddress: targetCoreAddress, msgs } }];
+  },
+  defaultTitle: (inputs) => `Execute admin messages on ${inputs.targetCoreAddress}`,
+  defaultDescription: () => "Executes the listed admin messages on the target SubDAO once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ targetCoreAddress: String(inputs.targetCoreAddress || "") }),
+  extraOutputSchema: [{ path: "targetCoreAddress", displayName: "Target Core Address", type: "string", description: "The SubDAO core address the admin messages execute on" }]
+});
+
+// src/core/lib/actionRegistry/actions/governance/daoAcceptToMarketplace.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.dao.accept-to-marketplace",
+  can: "governance.dao/accept-to-marketplace",
+  buildActions: (inputs) => {
+    const did = String(inputs.did || "").trim();
+    if (!did) throw new Error("did is required");
+    const relayerNodeDid = String(inputs.relayerNodeDid || "").trim();
+    if (!relayerNodeDid) throw new Error("relayerNodeDid is required");
+    const relayerNodeAddress = String(inputs.relayerNodeAddress || "").trim();
+    if (!relayerNodeAddress) throw new Error("relayerNodeAddress is required");
+    return [{ type: "AcceptToMarketplace", data: { did, relayerNodeDid, relayerNodeAddress } }];
+  },
+  defaultTitle: (inputs) => `Accept ${inputs.did} to the marketplace`,
+  defaultDescription: () => "Marks the entity as verified on the marketplace once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ entityDid: String(inputs.did || ""), relayerNodeDid: String(inputs.relayerNodeDid || "") }),
+  extraOutputSchema: [
+    { path: "entityDid", displayName: "Entity DID", type: "string", description: "The entity marked verified" },
+    { path: "relayerNodeDid", displayName: "Relayer Node DID", type: "string", description: "The relayer node vouching for the entity" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/daoCreateEntity.ts
+var DEFAULT_TYPE_URL = "/ixo.entity.v1beta1.MsgCreateEntity";
+registerGovernanceProposalAction({
+  type: "qi/governance.dao.create-entity",
+  can: "governance.dao/create-entity",
+  buildActions: (inputs) => {
+    const typeUrl = String(inputs.typeUrl || "").trim() || DEFAULT_TYPE_URL;
+    if (!typeUrl.startsWith("/")) throw new Error("typeUrl must be a fully-qualified message type url starting with \u201C/\u201D");
+    let value = inputs.value;
+    if (typeof value === "string") {
+      try {
+        value = JSON.parse(value);
+      } catch {
+        throw new Error("value must be valid JSON");
+      }
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error("value must be a JSON object with the message fields");
+    }
+    return [{ type: "CreateEntity", data: { typeUrl, value } }];
+  },
+  defaultTitle: () => "Create entity",
+  defaultDescription: (inputs) => `Broadcasts a ${String(inputs.typeUrl || "").trim() || DEFAULT_TYPE_URL} message once the proposal passes.`,
+  buildExtraOutput: (inputs) => ({ typeUrl: String(inputs.typeUrl || "").trim() || DEFAULT_TYPE_URL }),
+  extraOutputSchema: [{ path: "typeUrl", displayName: "Message Type URL", type: "string", description: "The stargate message type the proposal broadcasts" }]
+});
+
+// src/core/lib/actionRegistry/actions/governance/nftBurn.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.nft.burn",
+  can: "governance.nft/burn",
+  buildActions: (inputs) => {
+    const collection = String(inputs.collection || "").trim();
+    if (!collection) throw new Error("collection is required");
+    const tokenId = String(inputs.tokenId || "").trim();
+    if (!tokenId) throw new Error("tokenId is required");
+    return [{ type: "BurnNft", data: { collection, tokenId } }];
+  },
+  defaultTitle: (inputs) => `Burn NFT ${inputs.tokenId} from ${inputs.collection}`,
+  defaultDescription: () => "Permanently burns the NFT from the treasury once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ collection: String(inputs.collection || ""), tokenId: String(inputs.tokenId || "") }),
+  extraOutputSchema: [
+    { path: "collection", displayName: "Collection", type: "string", description: "The cw721 collection contract the token is burned from" },
+    { path: "tokenId", displayName: "Token ID", type: "string", description: "The id of the burned token" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/nftTransfer.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.nft.transfer",
+  can: "governance.nft/transfer",
+  buildActions: (inputs) => {
+    const collection = String(inputs.collection || "").trim();
+    if (!collection) throw new Error("collection is required");
+    const tokenId = String(inputs.tokenId || "").trim();
+    if (!tokenId) throw new Error("tokenId is required");
+    const recipient = String(inputs.recipient || "").trim();
+    if (!recipient) throw new Error("recipient is required");
+    const executeSmartContract = inputs.executeSmartContract === true || inputs.executeSmartContract === "true";
+    let smartContractMsg = "";
+    if (executeSmartContract) {
+      const raw = String(inputs.smartContractMsg || "").trim();
+      if (!raw) throw new Error("smartContractMsg is required when executeSmartContract is enabled");
+      try {
+        smartContractMsg = JSON.parse(raw);
+      } catch {
+        throw new Error("smartContractMsg must be valid JSON");
+      }
+    }
+    return [{ type: "TransferNft", data: { collection, tokenId, recipient, executeSmartContract, smartContractMsg } }];
+  },
+  defaultTitle: (inputs) => `Transfer NFT ${inputs.tokenId} to ${inputs.recipient}`,
+  defaultDescription: () => "Transfers the NFT from the treasury once the proposal passes.",
+  buildExtraOutput: (inputs) => ({
+    collection: String(inputs.collection || ""),
+    tokenId: String(inputs.tokenId || ""),
+    recipient: String(inputs.recipient || "")
+  }),
+  extraOutputSchema: [
+    { path: "collection", displayName: "Collection", type: "string", description: "The cw721 collection contract the token is transferred from" },
+    { path: "tokenId", displayName: "Token ID", type: "string", description: "The id of the transferred token" },
+    { path: "recipient", displayName: "Recipient", type: "string", description: "Destination address of the transfer" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/nftManageCollections.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.nft.manage-collections",
+  can: "governance.nft/manage-collections",
+  buildActions: (inputs) => {
+    const address = String(inputs.address || "").trim();
+    if (!address) throw new Error("address is required");
+    const adding = inputs.adding === true || inputs.adding === "true";
+    return [{ type: "ManageCw721", data: { adding, address } }];
+  },
+  defaultTitle: (inputs) => {
+    const adding = inputs.adding === true || inputs.adding === "true";
+    return `${adding ? "Track" : "Untrack"} NFT collection ${inputs.address}`;
+  },
+  defaultDescription: () => "Updates the NFT collections tracked in the treasury once the proposal passes.",
+  buildExtraOutput: (inputs) => ({
+    adding: String(inputs.adding === true || inputs.adding === "true"),
+    address: String(inputs.address || "")
+  }),
+  extraOutputSchema: [
+    { path: "adding", displayName: "Adding", type: "string", description: "Whether the collection is tracked (true) or untracked (false)" },
+    { path: "address", displayName: "Collection Address", type: "string", description: "The cw721 collection contract tracked or untracked" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/contractExecute.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.contract.execute",
+  can: "governance.contract/execute",
+  buildActions: (inputs) => {
+    const address = String(inputs.address || "").trim();
+    if (!address) throw new Error("address is required");
+    const message = String(inputs.message || "").trim();
+    if (!message) throw new Error("message is required");
+    try {
+      JSON.parse(message);
+    } catch {
+      throw new Error("message must be a valid JSON object");
+    }
+    const rawFunds = Array.isArray(inputs.funds) ? inputs.funds : [];
+    const funds = rawFunds.map((fund) => {
+      const denom = String(fund?.denom || "").trim();
+      if (!denom) throw new Error("every attached fund needs a denom");
+      const amount = String(fund?.amount || "").trim();
+      if (!/^\d+$/.test(amount) || BigInt(amount) <= 0n) {
+        throw new Error("every attached fund amount must be a positive whole number in base units");
+      }
+      return { denom, amount };
+    });
+    return [{ type: "Execute", data: { address, message, funds } }];
+  },
+  defaultTitle: (inputs) => `Execute a message on contract ${inputs.address}`,
+  defaultDescription: () => "Executes the message on the smart contract as the DAO once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ contractAddress: String(inputs.address || "") }),
+  extraOutputSchema: [{ path: "contractAddress", displayName: "Contract Address", type: "string", description: "The smart contract the message executes on" }]
+});
+
+// src/core/lib/actionRegistry/actions/governance/contractInstantiate.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.contract.instantiate",
+  can: "governance.contract/instantiate",
+  buildActions: (inputs) => {
+    const codeId = Number(inputs.codeId);
+    if (!Number.isInteger(codeId) || codeId <= 0) throw new Error("codeId must be a positive whole number");
+    const label = String(inputs.label || "").trim();
+    if (!label) throw new Error("label is required");
+    const admin = String(inputs.admin || "").trim() || String(inputs.coreAddress || "").trim();
+    if (!admin) throw new Error("admin is required (defaults to the group core address)");
+    const message = String(inputs.message || "").trim();
+    if (!message) throw new Error("message is required");
+    try {
+      JSON.parse(message);
+    } catch {
+      throw new Error("message must be a valid JSON object");
+    }
+    const rawFunds = Array.isArray(inputs.funds) ? inputs.funds : [];
+    const funds = rawFunds.map((fund) => {
+      const denom = String(fund?.denom || "").trim();
+      if (!denom) throw new Error("every attached fund needs a denom");
+      const amount = String(fund?.amount || "").trim();
+      if (!/^\d+$/.test(amount) || BigInt(amount) <= 0n) {
+        throw new Error("every attached fund amount must be a positive whole number in base units");
+      }
+      return { denom, amount };
+    });
+    return [{ type: "Instantiate", data: { admin, codeId, label, message, funds } }];
+  },
+  defaultTitle: (inputs) => `Instantiate code ${inputs.codeId} as \u201C${inputs.label}\u201D`,
+  defaultDescription: () => "Instantiates a new smart contract from the code id once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ codeId: String(inputs.codeId || ""), contractLabel: String(inputs.label || "") }),
+  extraOutputSchema: [
+    { path: "codeId", displayName: "Code ID", type: "string", description: "The wasm code id instantiated" },
+    { path: "contractLabel", displayName: "Contract Label", type: "string", description: "The label stored on the new contract" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/contractMigrate.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.contract.migrate",
+  can: "governance.contract/migrate",
+  buildActions: (inputs) => {
+    const contract = String(inputs.contract || "").trim();
+    if (!contract) throw new Error("contract is required");
+    const codeId = Number(inputs.codeId);
+    if (!Number.isInteger(codeId) || codeId <= 0) throw new Error("codeId must be a positive whole number");
+    const msg = String(inputs.msg || "").trim();
+    if (!msg) throw new Error("msg is required (use {} for contracts whose migrate entry point takes no data)");
+    try {
+      JSON.parse(msg);
+    } catch {
+      throw new Error("msg must be a valid JSON object");
+    }
+    return [{ type: "Migrate", data: { contract, codeId, msg } }];
+  },
+  defaultTitle: (inputs) => `Migrate contract ${inputs.contract} to code ${inputs.codeId}`,
+  defaultDescription: () => "Migrates the smart contract to the new code id once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ contractAddress: String(inputs.contract || ""), codeId: String(inputs.codeId || "") }),
+  extraOutputSchema: [
+    { path: "contractAddress", displayName: "Contract Address", type: "string", description: "The smart contract migrated" },
+    { path: "codeId", displayName: "Code ID", type: "string", description: "The wasm code id migrated to" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/contractUpdateAdmin.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.contract.update-admin",
+  can: "governance.contract/update-admin",
+  buildActions: (inputs) => {
+    const contract = String(inputs.contract || "").trim();
+    if (!contract) throw new Error("contract is required");
+    const newAdmin = String(inputs.newAdmin || "").trim();
+    if (!newAdmin) throw new Error("newAdmin is required");
+    return [{ type: "UpdateAdmin", data: { contract, newAdmin } }];
+  },
+  defaultTitle: (inputs) => `Update admin of ${inputs.contract} to ${inputs.newAdmin}`,
+  defaultDescription: () => "Transfers admin rights over the smart contract once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ contractAddress: String(inputs.contract || ""), newAdmin: String(inputs.newAdmin || "") }),
+  extraOutputSchema: [
+    { path: "contractAddress", displayName: "Contract Address", type: "string", description: "The smart contract whose admin changed" },
+    { path: "newAdmin", displayName: "New Admin", type: "string", description: "The address that becomes the contract admin" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/contractManageCw20.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.contract.manage-cw20",
+  can: "governance.contract/manage-cw20",
+  buildActions: (inputs) => {
+    const rawAdding = inputs.adding;
+    const adding = rawAdding === true || rawAdding === "true" ? true : rawAdding === false || rawAdding === "false" ? false : null;
+    if (adding === null) throw new Error("adding must be true (track the token) or false (untrack it)");
+    const address = String(inputs.address || "").trim();
+    if (!address) throw new Error("address is required");
+    return [{ type: "ManageCw20", data: { adding, address } }];
+  },
+  defaultTitle: (inputs) => {
+    const adding = inputs.adding === true || inputs.adding === "true";
+    return `${adding ? "Track" : "Untrack"} cw20 token ${inputs.address} in the treasury`;
+  },
+  defaultDescription: () => "Updates the treasury\u2019s cw20 token list once the proposal passes.",
+  buildExtraOutput: (inputs) => ({
+    tokenContract: String(inputs.address || ""),
+    adding: inputs.adding === true || inputs.adding === "true" ? "true" : "false"
+  }),
+  extraOutputSchema: [
+    { path: "tokenContract", displayName: "Token Contract", type: "string", description: "The cw20 token contract tracked or untracked" },
+    { path: "adding", displayName: "Tracking", type: "string", description: "'true' when the token was tracked, 'false' when untracked" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/validatorActions.ts
+var VALIDATOR_ACTION_LABELS = {
+  "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission": "Withdraw validator commission",
+  "/cosmos.staking.v1beta1.MsgCreateValidator": "Create validator",
+  "/cosmos.staking.v1beta1.MsgEditValidator": "Edit validator",
+  "/cosmos.slashing.v1beta1.MsgUnjail": "Unjail validator"
+};
+registerGovernanceProposalAction({
+  type: "qi/governance.validator.actions",
+  can: "governance.validator/actions",
+  buildActions: (inputs) => {
+    const validatorActionType = String(inputs.validatorActionType || "").trim();
+    if (!VALIDATOR_ACTION_LABELS[validatorActionType]) {
+      throw new Error("validatorActionType must be one of the supported typeUrls (MsgWithdrawValidatorCommission, MsgCreateValidator, MsgEditValidator, MsgUnjail)");
+    }
+    const isCreate = validatorActionType === "/cosmos.staking.v1beta1.MsgCreateValidator";
+    const isEdit = validatorActionType === "/cosmos.staking.v1beta1.MsgEditValidator";
+    let createMsg = "";
+    if (isCreate) {
+      createMsg = String(inputs.createMsg || "").trim();
+      if (!createMsg) throw new Error("createMsg is required for MsgCreateValidator");
+      try {
+        JSON.parse(createMsg);
+      } catch {
+        throw new Error("createMsg must be valid JSON");
+      }
+    }
+    let editMsg = "";
+    if (isEdit) {
+      editMsg = String(inputs.editMsg || "").trim();
+      if (!editMsg) throw new Error("editMsg is required for MsgEditValidator");
+      try {
+        JSON.parse(editMsg);
+      } catch {
+        throw new Error("editMsg must be valid JSON");
+      }
+    }
+    return [{ type: "ValidatorActions", data: { validatorActionType, createMsg, editMsg } }];
+  },
+  // buildActions runs first, so the action type is always a valid option here.
+  defaultTitle: (inputs) => `Validator action: ${VALIDATOR_ACTION_LABELS[String(inputs.validatorActionType)] || inputs.validatorActionType}`,
+  defaultDescription: () => "Executes the validator operation with the POD's validator account once the proposal passes.",
+  buildExtraOutput: (inputs) => ({
+    validatorActionType: String(inputs.validatorActionType || ""),
+    validatorActionLabel: VALIDATOR_ACTION_LABELS[String(inputs.validatorActionType)] || ""
+  }),
+  extraOutputSchema: [
+    { path: "validatorActionType", displayName: "Validator Action Type", type: "string", description: "The full cosmos typeUrl of the validator operation" },
+    { path: "validatorActionLabel", displayName: "Validator Action", type: "string", description: "Human-readable name of the validator operation" }
+  ]
+});
+
+// src/core/lib/actionRegistry/actions/governance/customMessage.ts
+registerGovernanceProposalAction({
+  type: "qi/governance.custom-message",
+  can: "governance/custom-message",
+  buildActions: (inputs) => {
+    const message = String(inputs.message || "").trim();
+    if (!message) throw new Error("message is required");
+    let parsed;
+    try {
+      parsed = JSON.parse(message);
+    } catch (err) {
+      throw new Error(`message must be valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error('message must be a JSON object \u2014 a single cosmos msg like {"bank":\u2026}, {"wasm":\u2026} or {"stargate":\u2026}');
+    }
+    return [{ type: "Custom", data: { message } }];
+  },
+  defaultTitle: () => "Execute custom message",
+  defaultDescription: () => "Executes the raw cosmos message exactly as written once the proposal passes.",
+  buildExtraOutput: (inputs) => ({ message: String(inputs.message || "") }),
+  extraOutputSchema: [{ path: "message", displayName: "Message", type: "string", description: "The raw JSON cosmos message the proposal executes" }]
+});
+
 // src/core/lib/actionRegistry/actions/httpRequest.ts
 registerAction({
   type: "qi/http.request",
@@ -1407,6 +2375,60 @@ registerAction({
   }
 });
 
+// src/core/lib/actionRegistry/actions/_shared/groupExecution.ts
+var GROUP_PROPOSAL_READBACK_KIND = "group-proposal";
+function isGroupExecution(inputs) {
+  return inputs?.actAsGroup === true || inputs?.actAsGroup === "true";
+}
+function requireGroupExecutionParams(inputs) {
+  const coreAddress = String(inputs.groupCoreAddress || "").trim();
+  if (!coreAddress) throw new Error("groupCoreAddress is required when acting as a POD");
+  const title = String(inputs.proposalTitle || "").trim();
+  if (!title) throw new Error("proposalTitle is required when acting as a POD \u2014 voters must see what they are approving");
+  const description = String(inputs.proposalDescription || "").trim();
+  if (!description) throw new Error("proposalDescription is required when acting as a POD \u2014 voters must see what they are approving");
+  return { coreAddress, title, description };
+}
+async function proposeGroupExecution(ctx, params) {
+  const handlers = ctx.handlers;
+  if (!handlers?.createGroupExecutionProposal) {
+    throw new Error("Group execution is not available: the host does not implement createGroupExecutionProposal");
+  }
+  const { coreAddress, title, description, msgs, expectedOutput, finalize, finalizeParams, completionEvent } = params;
+  const { proposalId, proposalContractAddress } = await handlers.createGroupExecutionProposal({
+    coreAddress,
+    title,
+    description,
+    msgs
+  });
+  if (proposalId === void 0 || proposalId === null || String(proposalId).trim() === "") {
+    throw new Error("POD proposal creation returned no proposal id. Check the handler logs.");
+  }
+  return {
+    output: {
+      ...expectedOutput,
+      groupExecution: true,
+      groupCoreAddress: coreAddress,
+      groupProposalId: String(proposalId),
+      groupProposalContractAddress: String(proposalContractAddress || ""),
+      proposalTitle: title,
+      proposalDescription: description
+    },
+    completion: {
+      state: "awaiting_readback",
+      readBack: {
+        kind: GROUP_PROPOSAL_READBACK_KIND,
+        proposalId: String(proposalId),
+        proposalContractAddress: String(proposalContractAddress || ""),
+        coreAddress,
+        expectedOutput,
+        ...completionEvent ? { completionEvent } : {},
+        ...finalize ? { finalize, finalizeParams: finalizeParams || {} } : {}
+      }
+    }
+  };
+}
+
 // src/core/lib/actionRegistry/actions/bid/bid.ts
 function normalizeBidRole(role) {
   const normalized = String(role || "").trim().toLowerCase();
@@ -1460,6 +2482,29 @@ registerAction({
       throw new Error("surveyAnswers must be an object");
     }
     const chainRole = normalizeBidRole(roleInput);
+    if (isGroupExecution(inputs)) {
+      const { coreAddress, title, description } = requireGroupExecutionParams(inputs);
+      return proposeGroupExecution(ctx, {
+        coreAddress,
+        title,
+        description,
+        msgs: [],
+        expectedOutput: {
+          bidId: "",
+          collectionId,
+          role: roleInput,
+          submitterDid: coreAddress,
+          deedDid
+        },
+        finalize: "bid.submit",
+        finalizeParams: {
+          collectionId,
+          role: chainRole,
+          surveyAnswers,
+          entityDid: deedDid || void 0
+        }
+      });
+    }
     const submission = await service.submitBid({
       collectionId,
       role: chainRole,
@@ -1552,6 +2597,71 @@ registerAction({
     if (!role) throw new Error("role is required");
     if (!applicantDid) throw new Error("applicantDid is required");
     if (!applicantAddress) throw new Error("applicantAddress is required");
+    if (isGroupExecution(inputs)) {
+      const { coreAddress, title, description } = requireGroupExecutionParams(inputs);
+      const expectedOutput = {
+        bidId,
+        decision,
+        status: decision === "approve" ? "approved" : "rejected",
+        evaluatedByDid: coreAddress,
+        evaluatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        reason: decision === "reject" ? String(inputs.reason || "") : "",
+        collectionId,
+        role,
+        deedDid,
+        applicantDid,
+        applicantAddress
+      };
+      if (decision === "approve") {
+        const adminAddress = String(inputs.adminAddress || "").trim();
+        if (!adminAddress) throw new Error("adminAddress is required when decision is approve");
+        if (!isServiceAgentRole(role) && !isEvaluationAgentRole(role)) {
+          throw new Error("Invalid role for evaluation. Expected service_agent or evaluation_agent");
+        }
+        const groupHandlers = ctx.handlers;
+        if (typeof groupHandlers?.prepareGroupAgentApplicationApproval !== "function") {
+          throw new Error("Acting as a POD is not available: the host does not implement prepareGroupAgentApplicationApproval");
+        }
+        let maxAmounts = inputs.maxAmounts;
+        if (typeof maxAmounts === "string" && maxAmounts.trim()) {
+          try {
+            maxAmounts = JSON.parse(maxAmounts);
+          } catch {
+            throw new Error("maxAmounts must be valid JSON when provided");
+          }
+        }
+        const prepared = await groupHandlers.prepareGroupAgentApplicationApproval({
+          groupAddress: coreAddress,
+          deedDid,
+          collectionId,
+          adminAddress,
+          role: isServiceAgentRole(role) ? "service_agent" : "evaluation_agent",
+          applicantAddress,
+          agentQuota: isServiceAgentRole(role) ? 30 : 10,
+          maxAmounts: Array.isArray(maxAmounts) ? maxAmounts : void 0
+        });
+        return proposeGroupExecution(ctx, {
+          coreAddress,
+          title,
+          description,
+          msgs: prepared.msgs || [],
+          expectedOutput,
+          finalize: "bid.approve",
+          finalizeParams: { bidId, collectionId, did: applicantDid, entityDid: deedDid }
+        });
+      }
+      const reason = String(inputs.reason || "").trim();
+      if (!reason) throw new Error("reason is required when decision is reject");
+      return proposeGroupExecution(ctx, {
+        coreAddress,
+        title,
+        description,
+        msgs: [],
+        expectedOutput,
+        finalize: "bid.reject",
+        finalizeParams: { bidId, collectionId, did: deedDid, reason, entityDid: deedDid }
+      });
+    }
     if (decision === "approve") {
       const adminAddress = String(inputs.adminAddress || "").trim();
       if (!adminAddress) {
@@ -1820,6 +2930,40 @@ registerAction({
     if (!pin) {
       throw new Error("PIN is required to submit claim");
     }
+    if (isGroupExecution(inputs)) {
+      const { coreAddress, title, description } = requireGroupExecutionParams(inputs);
+      const handlers = ctx.handlers;
+      if (typeof handlers?.prepareGroupClaimSubmission !== "function") {
+        throw new Error("Acting as a POD is not available: the host does not implement prepareGroupClaimSubmission");
+      }
+      const prepared = await handlers.prepareGroupClaimSubmission({
+        surveyData: surveyAnswers,
+        deedDid,
+        entityDid: deedDid,
+        collectionId,
+        adminAddress,
+        pin,
+        groupAddress: coreAddress
+      });
+      const claimId2 = String(prepared?.claimId || "").trim();
+      if (!claimId2) throw new Error("prepareGroupClaimSubmission returned no claim identifier");
+      return proposeGroupExecution(ctx, {
+        coreAddress,
+        title,
+        description,
+        msgs: prepared.msgs || [],
+        expectedOutput: {
+          claimId: claimId2,
+          transactionHash: "",
+          collectionId,
+          deedDid,
+          submittedByDid: coreAddress,
+          submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          surveyAnswers
+        },
+        completionEvent: "submitted"
+      });
+    }
     const result = await service.submitClaim({
       surveyData: surveyAnswers,
       deedDid,
@@ -2524,7 +3668,8 @@ registerAction({
     if (!deedDid) throw new Error("deedDid is required");
     if (!adminAddress) throw new Error("adminAddress is required");
     const handlers = ctx.handlers;
-    const actorAddress = String(ctx.actorDid || service.getCurrentUser?.()?.address || "").trim();
+    const groupMode = isGroupExecution(inputs);
+    const actorAddress = groupMode ? String(inputs.groupCoreAddress || "").trim() : String(ctx.actorDid || service.getCurrentUser?.()?.address || "").trim();
     if (!actorAddress) {
       throw new Error("Unable to resolve actor address for evaluator authorization");
     }
@@ -2598,6 +3743,54 @@ registerAction({
       });
       verificationProof = String(udid?.url || udid?.cid || "");
     }
+    if (groupMode) {
+      const { coreAddress, title, description } = requireGroupExecutionParams(inputs);
+      const groupHandlers = ctx.handlers;
+      if (typeof groupHandlers?.prepareGroupClaimEvaluation !== "function") {
+        throw new Error("Acting as a POD is not available: the host does not implement prepareGroupClaimEvaluation");
+      }
+      const prepared = await groupHandlers.prepareGroupClaimEvaluation({
+        groupAddress: coreAddress,
+        deedDid,
+        claimId,
+        collectionId,
+        adminAddress,
+        status: toStatus(decision),
+        verificationProof,
+        amount: normalizedCoin
+      });
+      let expectedSurveyAnswers = {};
+      try {
+        const getClaimData = groupHandlers?.getClaimData;
+        if (typeof getClaimData === "function") {
+          const claim = await getClaimData(collectionId, claimId, { entityDid: deedDid });
+          const candidate = claim?.credentialSubject ?? claim?.surveyAnswers ?? claim;
+          if (candidate && typeof candidate === "object" && !Array.isArray(candidate)) {
+            expectedSurveyAnswers = candidate;
+          }
+        }
+      } catch {
+      }
+      return proposeGroupExecution(ctx, {
+        coreAddress,
+        title,
+        description,
+        msgs: prepared.msgs || [],
+        expectedOutput: {
+          claimId,
+          decision,
+          status: decision === "approve" ? "approved" : "rejected",
+          verificationProof,
+          transactionHash: "",
+          collectionId,
+          deedDid,
+          evaluatedByDid: coreAddress,
+          evaluatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          surveyAnswers: expectedSurveyAnswers
+        },
+        completionEvent: "evaluated"
+      });
+    }
     const currentUser = service.getCurrentUser();
     const granteeAddress = String(inputs.granteeAddress || currentUser?.address || "").trim();
     if (!granteeAddress) {
@@ -6000,6 +7193,32 @@ registerAction({
         payments: inputs.payments,
         intents: inputs.intents
       };
+      if (isGroupExecution(inputs)) {
+        const { coreAddress, title, description } = requireGroupExecutionParams(inputs);
+        const groupHandlers = ctx.handlers;
+        if (typeof groupHandlers?.prepareGroupCollectionLifecycle !== "function") {
+          throw new Error("Acting as a POD is not available: the host does not implement prepareGroupCollectionLifecycle");
+        }
+        const prepared = await groupHandlers.prepareGroupCollectionLifecycle({
+          groupAddress: coreAddress,
+          operation: "create",
+          params: createParams
+        });
+        return proposeGroupExecution(ctx, {
+          coreAddress,
+          title,
+          description,
+          msgs: prepared.msgs || [],
+          expectedOutput: { collectionId: "", entity, protocol, state: inputs.state, startDate: inputs.startDate, endDate: inputs.endDate, quota, transactionHash: "" },
+          finalize: "collection.create-resolve",
+          finalizeParams: {
+            entityDid: entity,
+            protocolDid: protocol,
+            priorCollectionIds: Array.isArray(prepared.priorCollectionIds) ? prepared.priorCollectionIds : []
+          },
+          completionEvent: COLLECTION_CREATED_EVENT_NAME
+        });
+      }
       const result = await service.create(createParams);
       const transactionHash2 = String(result?.transactionHash || "").trim();
       const collectionId2 = String(result?.collectionId || "").trim();
@@ -6042,6 +7261,27 @@ registerAction({
     if (!adminAddress) {
       throw new Error(`${writeOp}: could not resolve admin address for collection "${collectionId}" (chain state has no admin). Cannot authorise the update.`);
     }
+    if (isGroupExecution(inputs)) {
+      const { coreAddress, title, description } = requireGroupExecutionParams(inputs);
+      const groupHandlers = ctx.handlers;
+      if (typeof groupHandlers?.prepareGroupCollectionLifecycle !== "function") {
+        throw new Error("Acting as a POD is not available: the host does not implement prepareGroupCollectionLifecycle");
+      }
+      const prepared = await groupHandlers.prepareGroupCollectionLifecycle({
+        groupAddress: coreAddress,
+        operation: writeOp,
+        params: { ...inputs, collectionId, adminAddress }
+      });
+      return proposeGroupExecution(ctx, {
+        coreAddress,
+        title,
+        description,
+        msgs: prepared.msgs || [],
+        expectedOutput: { ...current, collectionId, transactionHash: "" },
+        finalize: "collection.refresh",
+        finalizeParams: { collectionId }
+      });
+    }
     let transactionHash = "";
     switch (writeOp) {
       case "updateState": {
@@ -6201,6 +7441,53 @@ registerAction({
     if (!adminAddress) throw new Error(`${operation}: adminAddress (entity admin account) is required`);
     const role = normalizeRole(inputs.role);
     const deedDid = String(inputs.deedDid || "").trim() || void 0;
+    if (isGroupExecution(inputs) && (operation === "add" || operation === "revoke")) {
+      const { coreAddress, title, description } = requireGroupExecutionParams(inputs);
+      const groupHandlers = ctx.handlers;
+      if (typeof groupHandlers?.prepareGroupCollectionUserChange !== "function") {
+        throw new Error("Acting as a POD is not available: the host does not implement prepareGroupCollectionUserChange");
+      }
+      if (!deedDid) throw new Error(`${operation}: deedDid is required when acting as a POD`);
+      const grantees = [];
+      if (operation === "add" && inputs.granteeKind === "group-members") {
+        const members = Array.isArray(inputs.members) ? inputs.members.filter((m) => !!String(m?.address || "").trim()) : [];
+        if (members.length === 0) throw new Error("add (group-members): no members resolved to grant to.");
+        grantees.push(...members.map((m) => String(m.address).trim()));
+      } else {
+        const granteeAddress2 = String(inputs.granteeAddress || "").trim();
+        if (!granteeAddress2) throw new Error(`${operation}: granteeAddress is required`);
+        grantees.push(granteeAddress2);
+      }
+      const msgs = [];
+      for (const granteeAddress2 of grantees) {
+        const prepared = await groupHandlers.prepareGroupCollectionUserChange({
+          groupAddress: coreAddress,
+          operation,
+          entityDid: deedDid,
+          collectionId,
+          adminAddress,
+          role,
+          granteeAddress: granteeAddress2,
+          quota: inputs.agentQuota !== void 0 && inputs.agentQuota !== null ? Number(inputs.agentQuota) : void 0,
+          maxAmount: Array.isArray(inputs.maxAmount) ? inputs.maxAmount : void 0
+        });
+        msgs.push(...prepared.msgs || []);
+      }
+      return proposeGroupExecution(ctx, {
+        coreAddress,
+        title,
+        description,
+        msgs,
+        expectedOutput: {
+          transactionHash: "",
+          transactionHashes: [],
+          grantedCount: operation === "add" ? grantees.length : 0,
+          role,
+          collectionId,
+          granteeAddress: grantees.length === 1 ? grantees[0] : void 0
+        }
+      });
+    }
     if (operation === "revoke") {
       const granteeAddress2 = String(inputs.granteeAddress || "").trim();
       if (!granteeAddress2) throw new Error("revoke: granteeAddress is required");
@@ -9593,11 +10880,23 @@ var VERSION_MANIFEST = {
   }
 };
 var LATEST_VERSION = "1.0.0";
+var tempUcanEnforcementDisabled = true;
+function isTempUcanEnforcementDisabled() {
+  return tempUcanEnforcementDisabled;
+}
+function setTempUcanEnforcementDisabled(disabled) {
+  tempUcanEnforcementDisabled = disabled;
+}
 var MIGRATION_PATH = ["0.3", "1.0.0"];
 function getVersionPolicy(version) {
-  const policy = VERSION_MANIFEST[version];
-  if (!policy) {
-    return VERSION_MANIFEST[LATEST_VERSION];
+  const policy = VERSION_MANIFEST[version] ?? VERSION_MANIFEST[LATEST_VERSION];
+  if (tempUcanEnforcementDisabled && policy.ucanRequired) {
+    return {
+      ...policy,
+      ucanRequired: false,
+      delegationRootRequired: false,
+      ui: { ...policy.ui, requirePinForExecution: false }
+    };
   }
   return policy;
 }
@@ -10607,6 +11906,42 @@ import * as Y3 from "yjs";
 
 // src/core/lib/flowEngine/readBackReconciler.ts
 import * as Y2 from "yjs";
+function isYDoc(value) {
+  return value instanceof Y2.Doc;
+}
+function getYDoc(editorOrYDoc) {
+  if (!editorOrYDoc) return void 0;
+  if (isYDoc(editorOrYDoc)) return editorOrYDoc;
+  return editorOrYDoc._yDoc;
+}
+function getEditor(editorOrYDoc) {
+  return editorOrYDoc && !isYDoc(editorOrYDoc) ? editorOrYDoc : void 0;
+}
+function getRuntime(editorOrYDoc, runtime) {
+  if (runtime) return runtime;
+  const yDoc = getYDoc(editorOrYDoc);
+  if (yDoc) return createYDocRuntimeManager(yDoc);
+  return createRuntimeStateManager(!isYDoc(editorOrYDoc) ? editorOrYDoc : void 0);
+}
+function getReconcileEditor(params, yDoc, editor) {
+  if (editor) return editor;
+  if (!yDoc || !params.document) return void 0;
+  return {
+    _yDoc: yDoc,
+    _yRuntime: yDoc.getMap("runtime"),
+    document: params.document
+  };
+}
+function makeRunId(now) {
+  return `readback-${now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function asOutput(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
+}
+function errorRecord(error) {
+  if (!error) return void 0;
+  return typeof error === "string" ? { message: error } : { message: error.message, code: error.code };
+}
 function normalizeActionReadBackMetadata(params) {
   const base = params.readBack && typeof params.readBack === "object" && !Array.isArray(params.readBack) ? { ...params.readBack } : {};
   const kind = typeof base.kind === "string" && base.kind.trim() ? base.kind.trim() : params.actionType;
@@ -10631,14 +11966,221 @@ function normalizeActionReadBackMetadata(params) {
   }
   return normalized;
 }
+function writeReconciliationRunRecord(params) {
+  if (!params.yDoc) return void 0;
+  const completedAt = params.now();
+  const runId = makeRunId(params.now);
+  const pendingInvocation = params.readBack.pendingInvocation;
+  const details = {
+    runId,
+    output: params.output,
+    events: params.events,
+    startedAt: params.readBack.requestedAt || new Date(completedAt).toISOString(),
+    completedAt: new Date(completedAt).toISOString(),
+    actorDid: params.actorDid,
+    invocationCid: params.readBack.invocationCid,
+    capabilityId: params.readBack.capabilityId,
+    error: params.error,
+    readBack: params.readBack,
+    reconciled: true
+  };
+  if (pendingInvocation) {
+    details.fromPendingInvocationId = pendingInvocation.id;
+    details.triggeredBy = {
+      sourceBlockId: pendingInvocation.triggeringBlockId,
+      eventName: pendingInvocation.eventName
+    };
+    details.sourceRunId = pendingInvocation.sourceRunId;
+  }
+  appendRunRecord(params.yDoc, params.blockId, details, params.actorDid);
+  if (params.editor && params.events.length > 0) {
+    reconcilePendingInvocations(params.editor);
+  }
+  return runId;
+}
+async function reconcileActionReadBack(params) {
+  const now = params.now || Date.now;
+  const yDoc = getYDoc(params.editorOrYDoc);
+  const editor = getEditor(params.editorOrYDoc);
+  const runtime = getRuntime(params.editorOrYDoc, params.runtime);
+  const current = runtime.get(params.blockId);
+  const output = asOutput(current.output);
+  const readBack = current.readBack;
+  if (current.state !== "awaiting_readback" || !readBack?.kind) {
+    return {
+      success: false,
+      blockId: params.blockId,
+      state: current.state === "failed" ? "failed" : "pending",
+      output,
+      events: [],
+      error: `Block "${params.blockId}" is not awaiting read-back`,
+      pendingInvocationRemoved: false,
+      readBack
+    };
+  }
+  const resolver = params.resolver || params.resolvers?.[readBack.kind];
+  if (!resolver) {
+    return {
+      success: false,
+      blockId: params.blockId,
+      state: "pending",
+      output,
+      events: [],
+      error: `No read-back resolver registered for "${readBack.kind}"`,
+      pendingInvocationRemoved: false,
+      readBack
+    };
+  }
+  const resolution = await resolver({
+    blockId: params.blockId,
+    runtime: current,
+    output,
+    readBack
+  });
+  const checkedAt = now();
+  const checkedIso = new Date(checkedAt).toISOString();
+  const nextReadBack = {
+    ...readBack,
+    ...resolution.readBack || {},
+    status: resolution.state,
+    lastCheckedAt: checkedIso
+  };
+  if (resolution.state === "pending") {
+    runtime.update(params.blockId, {
+      readBack: nextReadBack
+    });
+    return {
+      success: true,
+      blockId: params.blockId,
+      state: "pending",
+      output,
+      events: resolution.events || [],
+      pendingInvocationRemoved: false,
+      readBack: nextReadBack
+    };
+  }
+  const events = resolution.events || [];
+  const finalOutput = {
+    ...output,
+    ...resolution.output || {}
+  };
+  const actorDid = params.actorDid || readBack.actorDid || current.executedByDid || "system:readback";
+  if (resolution.state === "failed") {
+    const error = errorRecord(resolution.error) || { message: "External read-back failed" };
+    const failedReadBack = {
+      ...nextReadBack,
+      terminalAt: checkedIso
+    };
+    runtime.update(params.blockId, {
+      state: "failed",
+      output: finalOutput,
+      error: { ...error, at: checkedAt },
+      readBack: failedReadBack
+    });
+    const runId2 = writeReconciliationRunRecord({
+      yDoc,
+      editor: getReconcileEditor(params, yDoc, editor),
+      blockId: params.blockId,
+      actorDid,
+      output: finalOutput,
+      events,
+      readBack: failedReadBack,
+      error,
+      now
+    });
+    return {
+      success: false,
+      blockId: params.blockId,
+      state: "failed",
+      output: finalOutput,
+      events,
+      error: error.message,
+      runId: runId2,
+      pendingInvocationRemoved: false,
+      readBack: failedReadBack
+    };
+  }
+  const readBackActionType = readBack.actionType || readBack.kind;
+  const actionDef = readBackActionType ? getAction(readBackActionType) : void 0;
+  if (actionDef) {
+    const proofCheck = validateActionProof(actionDef, finalOutput || {});
+    if (!proofCheck.valid) {
+      const message = proofCheck.reason || "Read-back resolved completed without proof of execution.";
+      const proofFailedReadBack = {
+        ...nextReadBack,
+        terminalAt: checkedIso
+      };
+      runtime.update(params.blockId, {
+        state: actionDef.sideEffect ? "needs_verification" : "failed",
+        output: finalOutput,
+        error: { message, code: PROOF_MISSING_CODE, at: checkedAt },
+        readBack: proofFailedReadBack
+      });
+      const failedRunId = writeReconciliationRunRecord({
+        yDoc,
+        editor: getReconcileEditor(params, yDoc, editor),
+        blockId: params.blockId,
+        actorDid,
+        output: finalOutput,
+        events,
+        readBack: proofFailedReadBack,
+        error: { message, code: PROOF_MISSING_CODE },
+        now
+      });
+      return {
+        success: false,
+        blockId: params.blockId,
+        state: "failed",
+        output: finalOutput,
+        events,
+        error: message,
+        runId: failedRunId,
+        pendingInvocationRemoved: false,
+        readBack: proofFailedReadBack
+      };
+    }
+  }
+  const completedReadBack = {
+    ...nextReadBack,
+    terminalAt: checkedIso
+  };
+  runtime.update(params.blockId, {
+    state: "completed",
+    output: finalOutput,
+    executedAt: checkedAt,
+    error: void 0,
+    readBack: completedReadBack
+  });
+  const runId = writeReconciliationRunRecord({
+    yDoc,
+    editor: getReconcileEditor(params, yDoc, editor),
+    blockId: params.blockId,
+    actorDid,
+    output: finalOutput,
+    events,
+    readBack: completedReadBack,
+    now
+  });
+  const pendingInvocationRemoved = Boolean(yDoc && completedReadBack.pendingInvocation?.id) && removePendingInvocation(yDoc, params.blockId, completedReadBack.pendingInvocation.id);
+  return {
+    success: true,
+    blockId: params.blockId,
+    state: "completed",
+    output: finalOutput,
+    events,
+    runId,
+    pendingInvocationRemoved,
+    readBack: completedReadBack
+  };
+}
 
 // src/core/lib/flowEngine/actionExecutor.ts
-function isYDoc(value) {
+function isYDoc2(value) {
   return value instanceof Y3.Doc;
 }
-function getYDoc(editorOrYDoc) {
+function getYDoc2(editorOrYDoc) {
   if (!editorOrYDoc) return void 0;
-  if (isYDoc(editorOrYDoc)) return editorOrYDoc;
+  if (isYDoc2(editorOrYDoc)) return editorOrYDoc;
   return editorOrYDoc._yDoc;
 }
 function parseInputs2(value) {
@@ -10653,20 +12195,20 @@ function parseInputs2(value) {
     return {};
   }
 }
-function getRuntime(editorOrYDoc, runtime) {
+function getRuntime2(editorOrYDoc, runtime) {
   if (runtime) return runtime;
-  const yDoc = getYDoc(editorOrYDoc);
+  const yDoc = getYDoc2(editorOrYDoc);
   if (yDoc) return createYDocRuntimeManager(yDoc);
-  return createRuntimeStateManager(!isYDoc(editorOrYDoc) ? editorOrYDoc : void 0);
+  return createRuntimeStateManager(!isYDoc2(editorOrYDoc) ? editorOrYDoc : void 0);
 }
-function getEditor(editorOrYDoc) {
-  return editorOrYDoc && !isYDoc(editorOrYDoc) ? editorOrYDoc : void 0;
+function getEditor2(editorOrYDoc) {
+  return editorOrYDoc && !isYDoc2(editorOrYDoc) ? editorOrYDoc : void 0;
 }
 function findBlock(params) {
   if (params.block) return params.block;
   const blockId = params.blockId;
   if (!blockId) return void 0;
-  const editor = getEditor(params.editorOrYDoc);
+  const editor = getEditor2(params.editorOrYDoc);
   return (params.document || editor?.document || []).find((block) => block?.id === blockId);
 }
 function getFlowMetadata(editor) {
@@ -10700,8 +12242,8 @@ function getNodeOutput(runtime, nodeId) {
 }
 function buildActionRunInputs(params) {
   const blockId = params.blockId || params.block?.id;
-  const yDoc = getYDoc(params.editorOrYDoc);
-  const runtime = getRuntime(params.editorOrYDoc, params.runtime);
+  const yDoc = getYDoc2(params.editorOrYDoc);
+  const runtime = getRuntime2(params.editorOrYDoc, params.runtime);
   const savedInputs = parseInputs2(params.savedInputs ?? params.block?.props?.inputs);
   const pendingInvocation = getPendingInvocation(yDoc, blockId, params.pendingInvocationId);
   const triggerContext = pendingInvocation ? {
@@ -10740,10 +12282,10 @@ function updateRuntimeFailure(runtime, blockId, message, now) {
     error: { message, at: now() }
   });
 }
-function makeRunId(now) {
+function makeRunId2(now) {
   return `run-${now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
-function getReconcileEditor(params, yDoc, editor) {
+function getReconcileEditor2(params, yDoc, editor) {
   if (editor) return editor;
   if (!yDoc || !params.document) return void 0;
   return {
@@ -10754,7 +12296,7 @@ function getReconcileEditor(params, yDoc, editor) {
 }
 function persistEvents(params) {
   if (!params.yDoc || params.events.length === 0) return void 0;
-  const runId = makeRunId(params.now);
+  const runId = makeRunId2(params.now);
   const details = {
     runId,
     output: params.output,
@@ -10786,9 +12328,9 @@ function cleanupCompletedPendingInvocation(yDoc, blockId, pendingInvocation) {
 async function executeActionBlock(params) {
   const block = findBlock(params);
   const blockId = params.blockId || block?.id;
-  const editor = getEditor(params.editorOrYDoc);
-  const yDoc = getYDoc(params.editorOrYDoc);
-  const runtime = getRuntime(params.editorOrYDoc, params.runtime);
+  const editor = getEditor2(params.editorOrYDoc);
+  const yDoc = getYDoc2(params.editorOrYDoc);
+  const runtime = getRuntime2(params.editorOrYDoc, params.runtime);
   const now = params.now || Date.now;
   if (!block || !blockId) {
     return buildFailureResult({
@@ -10948,7 +12490,7 @@ async function executeActionBlock(params) {
   });
   const runId = persistEvents({
     yDoc,
-    editor: getReconcileEditor(params, yDoc, editor),
+    editor: getReconcileEditor2(params, yDoc, editor),
     blockId,
     actorDid: params.actorDid,
     output,
@@ -12707,7 +14249,7 @@ var BLOCKER_DIAGNOSIS_VERSION = 2;
 function getBlocks(context) {
   return context.blocks || context.editor?.document || [];
 }
-function getRuntime2(yDoc, nodeId) {
+function getRuntime3(yDoc, nodeId) {
   const runtime = yDoc.getMap("runtime");
   const value = runtime.get(nodeId);
   return value && typeof value === "object" ? value : {};
@@ -12917,7 +14459,7 @@ function planRalphLoopCommands(context, options = {}) {
     const nodeId = getBlockId(block);
     if (!nodeId) continue;
     const pendingInvocationCount = readPendingInvocations(context.yDoc, nodeId).length;
-    const runtime = getRuntime2(context.yDoc, nodeId);
+    const runtime = getRuntime3(context.yDoc, nodeId);
     const actionType = getBlockActionType(block);
     const completionVerification = verifyCompletion({
       runtime,
@@ -13595,6 +15137,8 @@ export {
   replayFailedListenerRun,
   VERSION_MANIFEST,
   LATEST_VERSION,
+  isTempUcanEnforcementDisabled,
+  setTempUcanEnforcementDisabled,
   getVersionPolicy,
   isVersionAtLeast,
   reconcilePendingInvocations,
@@ -13609,6 +15153,7 @@ export {
   executeNode,
   PROOF_MISSING_CODE,
   validateActionProof,
+  reconcileActionReadBack,
   buildActionRunInputs,
   executeActionBlock,
   verifyCompletion,
@@ -13669,4 +15214,4 @@ export {
   executeQueuedFlowAgentCoreCommands,
   FlowAgentService
 };
-//# sourceMappingURL=chunk-GUKGNTGT.js.map
+//# sourceMappingURL=chunk-EULL3QTC.js.map