@usesigil/kit 0.16.0 → 0.18.0

package/dist/squads-detection.js

@@ -0,0 +1,124 @@
+/**
+ * G6 (audit 2026-05-18 cosign opt-in) — Squads V4 multisig detection helper.
+ *
+ * Read-only off-chain SDK helper that inspects whether a given vault owner
+ * pubkey is owned by the Squads V4 multisig program. Used by the dashboard
+ * to decide whether to surface the "single-signer protection" warning
+ * banner when the owner has not opted into TA-09 cosign enforcement.
+ *
+ * Categorization per AC-2 (Owner Key Leak) post-mitigation modes:
+ *
+ *   1. Solo key + cosign_required=false (default, low-friction):
+ *      owner signature alone authorizes elevated mutations. UI surfaces
+ *      a warning recommending Squads multisig OR enabling cosign.
+ *      Use case: dev/test, low-stakes vaults, AI agent automation.
+ *
+ *   2. Solo key + cosign_required=true (explicit opt-in):
+ *      TA-09 enforces cosign on elevated mutations. Use case: solo
+ *      founder wants Sigil-native per-mutation co-signature.
+ *
+ *   3. Squads V4 multisig owner + cosign_required=false (recommended
+ *      for production): multisig at the Solana layer enforces N-of-M
+ *      on every owner action; Sigil cosign is unnecessary on top.
+ *      Detection via this helper allows the dashboard to recognize
+ *      this mode and skip the warning banner.
+ *
+ * IMPORTANT: Sigil DOES NOT enforce multisig on-chain. The vault owner
+ * field is just a Pubkey. Squads is a separate Solana-level concern
+ * that users set up on their own at https://app.squads.so. This helper
+ * only DETECTS the configuration to give the dashboard ergonomic
+ * affordances — it is NOT a security boundary.
+ *
+ * Off-chain helper category per [INTERFACES_V2 §4.4]:
+ * (https://github.com/usesigil/agent-middleware/blob/main/docs/revamp/INTERFACES_V2.md)
+ * `TA-18` is the existing Squads detection primitive locked LOCKED-OFF-
+ * CHAIN-ONLY. This file is the V2 implementation surface for that
+ * primitive, scoped to the read-only program-owner check.
+ *
+ * @see https://docs.squads.so for Squads protocol documentation
+ * @see programs/sigil/src/instructions/queue_policy_update.rs — on-chain
+ *      cosign elevation gating gated on `policy.cosign_required`
+ */
+/**
+ * Squads V4 multisig program ID (mainnet + devnet — same address per
+ * https://docs.squads.so/main/v/development/squads-v4/program-addresses).
+ *
+ * Verified against the Squads V4 GitHub repo + the canonical Squads SDK
+ * docs (`@sqds/multisig`) as of 2026-05-18.
+ */
+export const SQUADS_V4_PROGRAM_ID = "SQDS4ep65T869zMMBKyuUq6aD6EgTu8psMjkvj52pCf";
+/**
+ * Read-only check: is the given pubkey an account owned by the Squads
+ * V4 multisig program?
+ *
+ * Reads `getAccountInfo(pubkey)` from the RPC and inspects the `owner`
+ * field. If the account doesn't exist, returns `isSquadsMultisig=false`
+ * and method `"account-missing"`. If the RPC call fails (network
+ * issue), returns `isSquadsMultisig=false` and method `"rpc-failure"` —
+ * fail-safe: assume not multisig and let the warning UI surface.
+ *
+ * Does NOT decode Squads-specific account data. Pure program-owner check.
+ * This is intentional — Sigil makes NO assumption about the multisig's
+ * threshold, member count, time-lock, or any other internal Squads
+ * configuration. The dashboard surfaces "this is a Squads vault" as a
+ * binary signal; users follow the link to squads.so to inspect the
+ * actual configuration.
+ *
+ * Performance: a single `getAccountInfo` RPC call. Suitable for
+ * dashboard read flows; not recommended for hot-path transaction
+ * building (cache the result for the session).
+ *
+ * @example
+ * ```ts
+ * import { detectSquadsV4Owner } from "@usesigil/kit";
+ *
+ * const result = await detectSquadsV4Owner(rpc, vaultOwnerPubkey);
+ * if (result.isSquadsMultisig) {
+ *   // AC-2 mode 3: multisig protection at the Solana layer.
+ *   // Suppress the "single-signer protection" warning banner.
+ * } else if (!policy.cosignRequired) {
+ *   // AC-2 mode 1: solo key + cosign opted out.
+ *   // Show the warning banner recommending Squads OR cosign.
+ * } else {
+ *   // AC-2 mode 2: solo key + cosign opted in.
+ *   // Sigil-native per-mutation co-signature. Show calmer banner.
+ * }
+ * ```
+ *
+ * @param rpc Kit RPC client (any cluster).
+ * @param ownerPubkey The vault owner pubkey to inspect.
+ * @returns Detection result; always resolved (never rejects).
+ */
+export async function detectSquadsV4Owner(rpc, ownerPubkey) {
+    try {
+        const response = await rpc
+            .getAccountInfo(ownerPubkey, { encoding: "base64" })
+            .send();
+        // Kit's getAccountInfo wraps the response in `{ value: ... | null }`.
+        // null = account does not exist OR was closed.
+        if (!response.value) {
+            return {
+                isSquadsMultisig: false,
+                programOwner: null,
+                detectionMethod: "account-missing",
+            };
+        }
+        const programOwner = response.value.owner;
+        return {
+            isSquadsMultisig: programOwner === SQUADS_V4_PROGRAM_ID,
+            programOwner,
+            detectionMethod: "program-owner",
+        };
+    }
+    catch {
+        // Fail-safe: any RPC error (network, malformed response, timeout)
+        // resolves to "not multisig". The UI warning banner surfaces;
+        // we never silently claim multisig protection on uncertain data.
+        return {
+            isSquadsMultisig: false,
+            programOwner: null,
+            detectionMethod: "rpc-failure",
+        };
+    }
+}
+//# sourceMappingURL=squads-detection.js.map

package/dist/squads-detection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"squads-detection.js","sourceRoot":"","sources":["../src/squads-detection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAKH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAC/B,6CAAwD,CAAC;AA6C3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,GAAsB,EACtB,WAAoB;IAEpB,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,MAAM,GAAG;aACvB,cAAc,CAAC,WAAW,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;aACnD,IAAI,EAAE,CAAC;QAEV,sEAAsE;QACtE,+CAA+C;QAC/C,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YACpB,OAAO;gBACL,gBAAgB,EAAE,KAAK;gBACvB,YAAY,EAAE,IAAI;gBAClB,eAAe,EAAE,iBAAiB;aACnC,CAAC;QACJ,CAAC;QAED,MAAM,YAAY,GAAG,QAAQ,CAAC,KAAK,CAAC,KAA2B,CAAC;QAChE,OAAO;YACL,gBAAgB,EAAE,YAAY,KAAK,oBAAoB;YACvD,YAAY;YACZ,eAAe,EAAE,eAAe;SACjC,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,kEAAkE;QAClE,8DAA8D;QAC9D,iEAAiE;QACjE,OAAO;YACL,gBAAgB,EAAE,KAAK;YACvB,YAAY,EAAE,IAAI;YAClB,eAAe,EAAE,aAAa;SAC/B,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/state-resolver.d.ts

@@ -11,13 +11,10 @@
 import { type Address, type ReadonlyUint8Array, type Rpc, type SolanaRpcApi } from "./kit-adapter.js";
 import { type AgentSpendOverlay } from "./generated/accounts/agentSpendOverlay.js";
 import { type AgentVault } from "./generated/accounts/agentVault.js";
-import { type InstructionConstraints } from "./generated/accounts/instructionConstraints.js";
 import { type PolicyConfig } from "./generated/accounts/policyConfig.js";
 import { type SpendTracker } from "./generated/accounts/spendTracker.js";
-import { type EscrowDeposit } from "./generated/accounts/escrowDeposit.js";
 import { type SessionAuthority } from "./generated/accounts/sessionAuthority.js";
 import { type PendingPolicyUpdate } from "./generated/accounts/pendingPolicyUpdate.js";
-import { type PendingConstraintsUpdate } from "./generated/accounts/pendingConstraintsUpdate.js";
 import type { AgentContributionEntry } from "./generated/types/agentContributionEntry.js";
 import { type Network } from "./types.js";
 /** Budget state for a single spending dimension. All values in USD (6 decimals). */
@@ -46,7 +43,6 @@ export interface ResolvedVaultState {
     policy: PolicyConfig;
     tracker: SpendTracker | null;
     overlay: AgentSpendOverlay | null;
-    constraints: InstructionConstraints | null;
     globalBudget: EffectiveBudget;
     agentBudget: EffectiveBudget | null;
     /** Per-agent budgets for all agents in the vault (indexed by agent address). */
@@ -164,13 +160,6 @@ export interface VaultLocator {
  */
 export type DiscoveredVault = VaultLocator;
 export declare function findVaultsByOwner(rpc: Rpc<SolanaRpcApi>, owner: Address, maxProbe?: number): Promise<VaultLocator[]>;
-/**
- * Find all escrow deposits where this vault is the source.
- * Uses getProgramAccounts with memcmp on source_vault field (offset 8).
- */
-export declare function findEscrowsByVault(rpc: Rpc<SolanaRpcApi>, sourceVault: Address): Promise<(EscrowDeposit & {
-    address: Address;
-})[]>;
 /**
  * Find all active sessions for a vault.
  * Uses getProgramAccounts with memcmp on vault field (offset 8).
@@ -183,9 +172,4 @@ export declare function findSessionsByVault(rpc: Rpc<SolanaRpcApi>, vault: Addre
  * Returns null if no pending update exists.
  */
 export declare function getPendingPolicyForVault(rpc: Rpc<SolanaRpcApi>, vault: Address): Promise<PendingPolicyUpdate | null>;
-/**
- * Fetch the pending constraints update for a vault, if any.
- * Returns null if no pending update exists.
- */
-export declare function getPendingConstraintsForVault(rpc: Rpc<SolanaRpcApi>, vault: Address): Promise<PendingConstraintsUpdate | null>;
 //# sourceMappingURL=state-resolver.d.ts.map

package/dist/state-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state-resolver.d.ts","sourceRoot":"","sources":["../src/state-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAKL,KAAK,OAAO,EAEZ,KAAK,kBAAkB,EACvB,KAAK,GAAG,EACR,KAAK,YAAY,EAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAEL,KAAK,UAAU,EAChB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,gDAAgD,CAAC;AACxD,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,kDAAkD,CAAC;AAC1D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AAiB1F,OAAO,EAaL,KAAK,OAAO,EACb,MAAM,YAAY,CAAC;AAMpB,oFAAoF;AACpF,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAe,SAAQ,eAAe;IACrD,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,iEAAiE;AACjE,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,oEAAoE;AACpE,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAClC,WAAW,EAAE,sBAAsB,GAAG,IAAI,CAAC;IAE3C,YAAY,EAAE,eAAe,CAAC;IAC9B,WAAW,EAAE,eAAe,GAAG,IAAI,CAAC;IACpC,gFAAgF;IAChF,eAAe,EAAE,GAAG,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;IAC/C,eAAe,EAAE,cAAc,EAAE,CAAC;IAClC,iBAAiB,EAAE,MAAM,CAAC;IAE1B,4EAA4E;IAC5E,kBAAkB,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAEnD,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAkBD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAEjE;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,EAC7C,YAAY,EAAE,OAAO,GACpB;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAmB5E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,MAAM,GACd,MAAM,CAsCR;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,sBAAsB,EAC7B,OAAO,EAAE,MAAM,GACd,MAAM,CA+CR;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,YAAY,EACrB,eAAe,EAAE,OAAO,EACxB,OAAO,EAAE,MAAM,GACd,MAAM,CAkBR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,YAAY,GAAG,IAAI,EAC5B,OAAO,EAAE,MAAM,GACd,aAAa,EAAE,CA8BjB;AAID;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,GAAG,CAAC,YAAY,CAAC,EACtB,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,kBAAkB,CAAC,CAoM7B;AAID,6EAA6E;AAC7E,MAAM,MAAM,0BAA0B,GAAG,IAAI,CAC3C,kBAAkB,EAClB,aAAa,CACd,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAsB,yBAAyB,CAC7C,GAAG,EAAE,GAAG,CAAC,YAAY,CAAC,EACtB,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,0BAA0B,CAAC,CAYrC;AAID,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,eAAe,CAAC;IAC9B,WAAW,EAAE,eAAe,GAAG,IAAI,CAAC;CACrC;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,GAAG,CAAC,YAAY,CAAC,EACtB,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,CAAC,CAgFzB;AAID,kDAAkD;AAClD,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC;AAqE3C,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,GAAG,CAAC,YAAY,CAAC,EACtB,KAAK,EAAE,OAAO,EACd,QAAQ,GAAE,MAAW,GACpB,OAAO,CAAC,YAAY,EAAE,CAAC,CAwFzB;AAOD;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,GAAG,CAAC,YAAY,CAAC,EACtB,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,CAAC,aAAa,GAAG;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,EAAE,CAAC,CAiCnD;AAOD;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,GAAG,CAAC,YAAY,CAAC,EACtB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,CAAC,gBAAgB,GAAG;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,EAAE,CAAC,CAiCtD;AAID;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,GAAG,CAAC,YAAY,CAAC,EACtB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAIrC;AAED;;;GAGG;AACH,wBAAsB,6BAA6B,CACjD,GAAG,EAAE,GAAG,CAAC,YAAY,CAAC,EACtB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,wBAAwB,GAAG,IAAI,CAAC,CAI1C"}
+{"version":3,"file":"state-resolver.d.ts","sourceRoot":"","sources":["../src/state-resolver.ts"],"names":[],"mappings":"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"}

package/dist/state-resolver.js

@@ -11,16 +11,15 @@
 import { fetchEncodedAccounts, getAddressDecoder, getAddressEncoder, getU64Decoder, } from "./kit-adapter.js";
 import { decodeAgentSpendOverlay, } from "./generated/accounts/agentSpendOverlay.js";
 import { decodeAgentVault, } from "./generated/accounts/agentVault.js";
-import { decodeInstructionConstraints, } from "./generated/accounts/instructionConstraints.js";
+// M1-04: InstructionConstraints account import removed (constraints engine deleted).
 import { decodePolicyConfig, } from "./generated/accounts/policyConfig.js";
 import { decodeSpendTracker, } from "./generated/accounts/spendTracker.js";
-import { getEscrowDepositDecoder, } from "./generated/accounts/escrowDeposit.js";
+// EscrowDeposit import REMOVED in v2 revamp Stage 1.
 import { getSessionAuthorityDecoder, getSessionAuthoritySize, } from "./generated/accounts/sessionAuthority.js";
 import { fetchMaybePendingPolicyUpdate, } from "./generated/accounts/pendingPolicyUpdate.js";
-import { fetchMaybePendingConstraintsUpdate, } from "./generated/accounts/pendingConstraintsUpdate.js";
 import { SigilSdkDomainError } from "./errors/sdk.js";
 import { SIGIL_ERROR__SDK__VAULT_NOT_FOUND, SIGIL_ERROR__SDK__POLICY_NOT_FOUND, } from "./errors/codes.js";
-import { getVaultPDA, getPolicyPDA, getTrackerPDA, getAgentOverlayPDA, getConstraintsPDA, getPendingPolicyPDA, getPendingConstraintsPDA, } from "./resolve-accounts.js";
+import { getVaultPDA, getVaultPdaFromState, getPolicyPDA, getTrackerPDA, getAgentOverlayPDA, getPendingPolicyPDA, } from "./resolve-accounts.js";
 import { EPOCH_DURATION, NUM_EPOCHS, OVERLAY_EPOCH_DURATION, OVERLAY_NUM_EPOCHS, SIGIL_PROGRAM_ADDRESS, ROLLING_WINDOW_SECONDS, U64_MAX, USDC_MINT_DEVNET, USDC_MINT_MAINNET, USDT_MINT_DEVNET, USDT_MINT_MAINNET, } from "./types.js";
 import { deriveAta } from "./tokens.js";
 import { formatUsd } from "./formatting.js";
@@ -247,21 +246,20 @@ export async function resolveVaultState(rpc, vault, agent, nowUnix, network) {
     const usdcMint = net === "devnet" ? USDC_MINT_DEVNET : USDC_MINT_MAINNET;
     const usdtMint = net === "devnet" ? USDT_MINT_DEVNET : USDT_MINT_MAINNET;
     // 1. Derive PDAs + stablecoin ATAs in parallel
-    const [[policyPda], [trackerPda], [overlayPda], [constraintsPda], vaultUsdcAta, vaultUsdtAta,] = await Promise.all([
+    // M1-04: constraints PDA removed from the resolve flow (constraints engine gone).
+    const [[policyPda], [trackerPda], [overlayPda], vaultUsdcAta, vaultUsdtAta] = await Promise.all([
         getPolicyPDA(vault),
         getTrackerPDA(vault),
         getAgentOverlayPDA(vault, 0),
-        getConstraintsPDA(vault),
         deriveAta(vault, usdcMint),
         deriveAta(vault, usdtMint),
     ]);
-    // 2. Single batch fetch (one RPC round-trip — 7 accounts)
+    // 2. Single batch fetch (one RPC round-trip — 6 accounts)
     const encoded = await fetchEncodedAccounts(rpc, [
         vault,
         policyPda,
         trackerPda,
         overlayPda,
-        constraintsPda,
         vaultUsdcAta,
         vaultUsdtAta,
     ]);
@@ -282,10 +280,7 @@ export async function resolveVaultState(rpc, vault, agent, nowUnix, network) {
     const overlay = decodedOverlay.exists
         ? decodedOverlay.data
         : null;
-    const decodedConstraints = decodeInstructionConstraints(encoded[4]);
-    const constraints = decodedConstraints.exists
-        ? decodedConstraints.data
-        : null;
+    // M1-04: constraints decode removed. ATAs are now encoded[4]/encoded[5].
     // 4. Timestamp
     const timestamp = nowUnix ?? BigInt(Math.floor(Date.now() / 1000));
     // 5. Global budget
@@ -368,7 +363,7 @@ export async function resolveVaultState(rpc, vault, agent, nowUnix, network) {
     // substituting zero.
     let usdcBalance = 0n;
     let usdtBalance = 0n;
-    const usdcEncoded = encoded[5];
+    const usdcEncoded = encoded[4];
     if (usdcEncoded?.exists) {
         const usdcData = usdcEncoded.data;
         if (usdcData && usdcData.length >= 72) {
@@ -382,7 +377,7 @@ export async function resolveVaultState(rpc, vault, agent, nowUnix, network) {
             }
         }
     }
-    const usdtEncoded = encoded[6];
+    const usdtEncoded = encoded[5];
     if (usdtEncoded?.exists) {
         const usdtData = usdtEncoded.data;
         if (usdtData && usdtData.length >= 72) {
@@ -396,7 +391,6 @@ export async function resolveVaultState(rpc, vault, agent, nowUnix, network) {
         policy: decodedPolicy.data,
         tracker,
         overlay,
-        constraints,
         globalBudget,
         agentBudget,
         allAgentBudgets,
@@ -497,10 +491,35 @@ export async function resolveVaultBudget(rpc, vault, agent, nowUnix) {
     }
     return { globalBudget, agentBudget };
 }
-/** AgentVault account size (bytes) — used for dataSize filter. */
-const AGENT_VAULT_SIZE = 634;
+/**
+ * AgentVault account size (bytes) — used for the GPA `dataSize` filter.
+ *
+ * Pinned to 676 to match the on-chain layout
+ * (`programs/sigil/src/state/vault.rs` — `AgentVault::SIZE == 676`
+ * with compile-time assertion; F-Q6 2026-06-02 added owner_type +1). The layout adds 32 bytes
+ * for `vault_authority` at the tail; pre-LBL-01 vaults at 634 bytes no
+ * longer exist on-chain (Phase 10 will redeploy under a new program ID
+ * with fresh state).
+ *
+ * Cross-cutting regression hunt fix (audit 2026-05-21): previously held
+ * the stale 634 value, which caused `findVaultsByOwner` to silently return
+ * `[]` on every call against a real RPC (the mock RPC used by the test
+ * suite ignores filters, masking the regression). Closed by promoting the
+ * documented invariant to live code.
+ */
+const AGENT_VAULT_SIZE = 676;
 /** Byte offset of the `vault_id` field in AgentVault (after 8 disc + 32 owner). */
 const VAULT_ID_OFFSET = 40;
+/**
+ * Byte offset of the `vault_authority` field in AgentVault — the Phase 8
+ * LBL-01 `Pubkey` (32 bytes) remains the FINAL 32 bytes of the layout
+ * (F-Q6 2026-06-02 inserted owner_type BEFORE it precisely to preserve this),
+ * so the field sits at `AgentVault::SIZE - 32 = 644`. Used by H-5 to re-derive
+ * vault PDAs from the IMMUTABLE seed key (which survives
+ * `accept_ownership_transfer`) rather than the mutable `vault.owner`
+ * byte at offset 8.
+ */
+const VAULT_AUTHORITY_OFFSET = 644;
 const u64Decoder = getU64Decoder();
 /**
  * Find all vaults owned by a wallet address.
@@ -556,15 +575,93 @@ function base64ToUint8(base64) {
     }
     return bytes;
 }
+/**
+ * Strategy B: PDA probing fallback — derive `cappedProbe` candidate vault
+ * PDAs (ids `0..cappedProbe-1`) seeded with `owner` and batch-fetch them.
+ *
+ * H-5 note: probing seeds with the CALLER's `owner` only finds vaults
+ * for which `vault.vault_authority == owner` — i.e. vaults the caller
+ * originally initialized. Vaults the caller received via
+ * `accept_ownership_transfer` are invisible to probing because the
+ * immutable seed-key still belongs to the original initializer; there
+ * is no way to probe with an unknown seed-key. RPCs that support
+ * `getProgramAccounts` (Strategy A) handle the transferred case
+ * correctly via the H-5 `vault_authority` re-derivation.
+ *
+ * ADDRESS-authoritative, not DATA-verified: every returned address is
+ * re-derived client-side from `(owner, vaultId)`, so the RPC cannot point
+ * the caller at an arbitrary fabricated address — a returned `vaultAddress`
+ * is always the genuine vault PDA for `(owner, vaultId)`. Unlike Strategy A,
+ * this path does NOT decode the account body (no discriminator / owner /
+ * `vault_authority` re-check). A malicious or buggy RPC can therefore still
+ * lie about EXISTENCE — report a real PDA absent, or report a non-existent
+ * PDA present with garbage bytes. The address can't be spoofed; the presence
+ * bit can. Callers that need the body validated must re-fetch and decode:
+ * `discoverVaults` does exactly this via `fetchMaybeAgentVault`, dropping any
+ * locator whose on-chain account fails the discriminator/layout decode — so a
+ * presence-lie cannot survive into a `DiscoveredVault`.
+ */
+async function probeVaultsByOwner(rpc, owner, cappedProbe) {
+    if (cappedProbe === 0)
+        return [];
+    const pdas = await Promise.all(Array.from({ length: cappedProbe }, async (_, i) => {
+        const [pda] = await getVaultPDA(owner, BigInt(i));
+        return { address: pda, vaultId: BigInt(i) };
+    }));
+    // Batch fetch via getMultipleAccounts (cappedProbe <= 100-account limit)
+    const addresses = pdas.map((p) => p.address);
+    const result = await rpc
+        .getMultipleAccounts(addresses, { encoding: "base64" })
+        .send();
+    const discovered = [];
+    for (let i = 0; i < result.value.length; i++) {
+        if (result.value[i] !== null) {
+            discovered.push({
+                vaultAddress: pdas[i].address,
+                vaultId: pdas[i].vaultId,
+            });
+        }
+    }
+    // Already sorted by vaultId (probed sequentially 0..cappedProbe)
+    return discovered;
+}
 export async function findVaultsByOwner(rpc, owner, maxProbe = 20) {
     // Cap maxProbe to prevent excessive PDA derivation (V-3: DoS mitigation)
     const cappedProbe = Math.min(Math.max(0, maxProbe), 100);
     const ownerBase64 = uint8ToBase64(addressEncoder.encode(owner));
-    // Strategy A: getProgramAccounts with memcmp filter
+    // Strategy A: getProgramAccounts with memcmp filter.
+    //
+    // H-5 (pre-redeploy audit 2026-05-21): the `memcmp` at offset 8 filters
+    // by the MUTABLE `vault.owner` byte field, so vaults the caller
+    // currently owns appear here (including those received via
+    // `accept_ownership_transfer`). The V-1 re-derivation below MUST use
+    // the IMMUTABLE Phase 8 LBL-01 seed-key `vault.vault_authority`
+    // (offset 644), NOT the current `owner` — passing `owner` for a
+    // transferred vault produces a PDA address that doesn't match the
+    // entry's `pubkey` and the entry would be silently dropped.
+    //
+    // To get both `vault_id` AND `vault_authority` in one RPC round we
+    // drop the `dataSlice` and parse both fields from the full account
+    // body. Bandwidth cost is bounded — vaults per owner are O(1) in
+    // practice and the full body is ~675 bytes.
+    //
+    // A devnet / public RPC that restricts `getProgramAccounts` for a
+    // high-account-count program does NOT always error — it can silently
+    // return `[]` (the program is excluded from the secondary index, or the
+    // index is transiently inconsistent). That empty result is
+    // indistinguishable, from Strategy A alone, from a genuinely vault-less
+    // owner. So when Strategy A yields zero verified vaults we DON'T return
+    // `[]` outright — we fall through to the PDA-probing fallback (Strategy B
+    // below). Probing is authoritative for low ids (`0..cappedProbe`) and
+    // cannot fabricate an address, so it can only ADD real vaults the
+    // restricted gPA hid; it never masks a genuinely-empty owner (probing
+    // returns `[]` for one). This closes the silent under-reporting bug where
+    // a restricted RPC made `discoverVaults` report "no vaults" for an owner
+    // that has them (devnet CI flake 2026-06-11). Only a NON-empty Strategy A
+    // result short-circuits (returns early) before probing.
     try {
         const accounts = await rpc
             .getProgramAccounts(SIGIL_PROGRAM_ADDRESS, {
-            dataSlice: { offset: VAULT_ID_OFFSET, length: 8 },
             filters: [
                 { dataSize: BigInt(AGENT_VAULT_SIZE) },
                 {
@@ -578,22 +675,44 @@ export async function findVaultsByOwner(rpc, owner, maxProbe = 20) {
             encoding: "base64",
         })
             .send();
-        const parsed = accounts.map((entry) => {
+        // H-5 verification: parse `vault_id` at offset 40 AND
+        // `vault_authority` at offset 644 from each returned account, then
+        // re-derive the PDA from `vault_authority` (NOT `owner`). Drop any
+        // entry whose body is too short to contain `vault_authority` (a
+        // malformed / truncated response or a malicious RPC).
+        const parsed = accounts.flatMap((entry) => {
             const raw = base64ToUint8(entry.account.data[0]);
-            const vaultId = u64Decoder.decode(raw);
-            return { vaultAddress: entry.pubkey, vaultId };
+            if (raw.length < VAULT_AUTHORITY_OFFSET + 32)
+                return [];
+            const vaultId = u64Decoder.decode(raw.subarray(VAULT_ID_OFFSET));
+            const vaultAuthority = addressDecoder.decode(raw.subarray(VAULT_AUTHORITY_OFFSET, VAULT_AUTHORITY_OFFSET + 32));
+            return [{ vaultAddress: entry.pubkey, vaultId, vaultAuthority }];
         });
-        // V-1 fix: Re-derive PDAs to verify RPC-returned pubkeys are legitimate vault addresses.
-        // A malicious RPC could return fabricated pubkeys that don't correspond to real vault PDAs.
+        // V-1 + H-5: re-derive PDAs from `vault_authority` (the immutable
+        // PDA seed) to verify RPC-returned pubkeys are legitimate vault
+        // addresses. A malicious RPC could otherwise return fabricated
+        // pubkeys that don't correspond to real vault PDAs.
         const verified = [];
         for (const entry of parsed) {
-            const [expectedPda] = await getVaultPDA(owner, entry.vaultId);
+            const [expectedPda] = await getVaultPdaFromState({
+                vaultAuthority: entry.vaultAuthority,
+                vaultId: entry.vaultId,
+            });
             if (expectedPda === entry.vaultAddress) {
-                verified.push(entry);
+                verified.push({
+                    vaultAddress: entry.vaultAddress,
+                    vaultId: entry.vaultId,
+                });
             }
         }
-        // Sort by vaultId for consistent ordering regardless of RPC response order
-        return verified.sort((a, b) => a.vaultId < b.vaultId ? -1 : a.vaultId > b.vaultId ? 1 : 0);
+        // Strategy A succeeded with results — return them sorted. Only when
+        // it yielded ZERO do we fall through to the probing safety net below
+        // (a restricted RPC can silently return [] for an owner with vaults).
+        if (verified.length > 0) {
+            return verified.sort((a, b) => a.vaultId < b.vaultId ? -1 : a.vaultId > b.vaultId ? 1 : 0);
+        }
+        // verified.length === 0 — fall through to the Strategy B probing safety
+        // net (a restricted RPC can silently return [] for an owner with vaults).
     }
     catch (err) {
         // Rate limits must propagate — never fall back to slow probing under rate limit
@@ -608,67 +727,21 @@ export async function findVaultsByOwner(rpc, owner, maxProbe = 20) {
             throw err;
         }
     }
-    // Strategy B: PDA probing fallback — derive all candidate PDAs in parallel
-    const pdas = await Promise.all(Array.from({ length: cappedProbe }, async (_, i) => {
-        const [pda] = await getVaultPDA(owner, BigInt(i));
-        return { address: pda, vaultId: BigInt(i) };
-    }));
-    // Batch fetch via getMultipleAccounts (maxProbe <= 20, well under 100-account limit)
-    const addresses = pdas.map((p) => p.address);
-    const result = await rpc
-        .getMultipleAccounts(addresses, { encoding: "base64" })
-        .send();
-    const discovered = [];
-    for (let i = 0; i < result.value.length; i++) {
-        if (result.value[i] !== null) {
-            discovered.push({
-                vaultAddress: pdas[i].address,
-                vaultId: pdas[i].vaultId,
-            });
-        }
-    }
-    // Already sorted by vaultId (probed sequentially 0..maxProbe)
-    return discovered;
-}
-// ─── Escrow Discovery ──────────────────────────────────────────────────────
-/** Escrow account size (bytes) — used for dataSize filter. */
-const ESCROW_DEPOSIT_SIZE = 170;
-/**
- * Find all escrow deposits where this vault is the source.
- * Uses getProgramAccounts with memcmp on source_vault field (offset 8).
- */
-export async function findEscrowsByVault(rpc, sourceVault) {
-    const vaultBase64 = uint8ToBase64(addressEncoder.encode(sourceVault));
-    try {
-        const accounts = await rpc
-            .getProgramAccounts(SIGIL_PROGRAM_ADDRESS, {
-            filters: [
-                { dataSize: BigInt(ESCROW_DEPOSIT_SIZE) },
-                {
-                    memcmp: {
-                        offset: BigInt(8),
-                        bytes: vaultBase64,
-                        encoding: "base64",
-                    },
-                },
-            ],
-            encoding: "base64",
-        })
-            .send();
-        // Decode directly from GPA response (avoids double RPC)
-        const decoder = getEscrowDepositDecoder();
-        return accounts.map((entry) => {
-            const raw = base64ToUint8(entry.account.data[0]);
-            const data = decoder.decode(raw);
-            return { ...data, address: entry.pubkey };
-        });
-    }
-    catch (err) {
-        if (!isGpaUnsupportedError(err))
-            throw err;
-        return []; // GPA not supported — return empty
-    }
+    // Strategy B: PDA probing fallback. Reached only when Strategy A produced
+    // ZERO usable vaults — either (a) it threw a gpa-unsupported error (handled
+    // in the catch above), or (b) it ran but returned an empty verified set
+    // (possibly a restricted RPC silently returning [] for an owner that
+    // actually has vaults). In BOTH cases Strategy A contributed nothing, so
+    // probing's result is the whole answer — there is nothing to merge.
+    //
+    // Probing only covers low ids (`0..cappedProbe`): a high-id vault hidden by
+    // a restricted gPA stays hidden. That is an honest limitation (probing
+    // cannot enumerate an unbounded id space), not a silent corruption — a
+    // genuinely vault-less owner still gets [].
+    return probeVaultsByOwner(rpc, owner, cappedProbe);
 }
+// Escrow discovery (findEscrowsByVault, ESCROW_DEPOSIT_SIZE) REMOVED in v2
+// revamp Stage 1 — escrow feature deleted.
 // ─── Session Discovery ─────────────────────────────────────────────────────
 /** SessionAuthority account size (bytes) — sourced from generated code to avoid drift. */
 const SESSION_AUTHORITY_SIZE = getSessionAuthoritySize();
@@ -718,13 +791,5 @@ export async function getPendingPolicyForVault(rpc, vault) {
     const result = await fetchMaybePendingPolicyUpdate(rpc, pda);
     return result.exists ? result.data : null;
 }
-/**
- * Fetch the pending constraints update for a vault, if any.
- * Returns null if no pending update exists.
- */
-export async function getPendingConstraintsForVault(rpc, vault) {
-    const [pda] = await getPendingConstraintsPDA(vault);
-    const result = await fetchMaybePendingConstraintsUpdate(rpc, pda);
-    return result.exists ? result.data : null;
-}
+// M1-04: getPendingConstraintsForVault removed with the constraints engine.
 //# sourceMappingURL=state-resolver.js.map